﻿namespace Vanara.PInvoke;

/// <summary>Platform invokable enumerated types, constants and functions from ntdll.h</summary>
public static partial class NtDll
{
	/// <summary>A <b>FILE_INFORMATION_CLASS</b> value specifies which structure to use to query or set information for a file object.</summary>
	// https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/ne-wdm-_file_information_class
	[PInvokeData("wdm.h", MSDNShortId = "NE:wdm._FILE_INFORMATION_CLASS")]
	public enum FILE_INFORMATION_CLASS
	{
		/// <summary>
		/// <para>Value:</para>
		/// <para>1</para>
		/// <para>A FILE_DIRECTORY_INFORMATION structure.</para>
		/// </summary>
		[CorrespondingType(typeof(FILE_DIRECTORY_INFORMATION))]
		FileDirectoryInformation = 1,

		/// <summary>
		/// <para>Value:</para>
		/// <para>2</para>
		/// <para>A FILE_FULL_DIR_INFORMATION structure.</para>
		/// </summary>
		[CorrespondingType(typeof(FILE_FULL_DIR_INFORMATION))]
		FileFullDirectoryInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>3</para>
		/// <para>A FILE_BOTH_DIR_INFORMATION structure.</para>
		/// </summary>
		[CorrespondingType(typeof(FILE_BOTH_DIR_INFORMATION))]
		FileBothDirectoryInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>4</para>
		/// <para>A FILE_BASIC_INFORMATION structure.</para>
		/// </summary>
		[CorrespondingType(typeof(FILE_BASIC_INFORMATION))]
		FileBasicInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>5</para>
		/// <para>A FILE_STANDARD_INFORMATION structure.</para>
		/// </summary>
		[CorrespondingType(typeof(FILE_STANDARD_INFORMATION))]
		FileStandardInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>6</para>
		/// <para>A FILE_INTERNAL_INFORMATION structure.</para>
		/// </summary>
		[CorrespondingType(typeof(FILE_INTERNAL_INFORMATION))]
		FileInternalInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>7</para>
		/// <para>A FILE_EA_INFORMATION structure.</para>
		/// </summary>
		[CorrespondingType(typeof(FILE_EA_INFORMATION))]
		FileEaInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>8</para>
		/// <para>A FILE_ACCESS_INFORMATION structure.</para>
		/// </summary>
		[CorrespondingType(typeof(FILE_ACCESS_INFORMATION))]
		FileAccessInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>9</para>
		/// <para>A FILE_NAME_INFORMATION structure.</para>
		/// </summary>
		[CorrespondingType(typeof(FILE_NAME_INFORMATION))]
		FileNameInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>10</para>
		/// <para>A FILE_RENAME_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_RENAME_INFORMATION))]
		FileRenameInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>11</para>
		/// <para>A FILE_LINK_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_LINK_INFORMATION))]
		FileLinkInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>12</para>
		/// <para>A FILE_NAMES_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_NAMES_INFORMATION))]
		FileNamesInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>13</para>
		/// <para>A FILE_DISPOSITION_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_DISPOSITION_INFORMATION))]
		FileDispositionInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>14</para>
		/// <para>A FILE_POSITION_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_POSITION_INFORMATION))]
		FilePositionInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>15</para>
		/// <para>A FILE_FULL_EA_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_FULL_EA_INFORMATION))]
		FileFullEaInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>16</para>
		/// <para>A FILE_MODE_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_MODE_INFORMATION))]
		FileModeInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>17</para>
		/// <para>A FILE_ALIGNMENT_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_ALIGNMENT_INFORMATION))]
		FileAlignmentInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>18</para>
		/// <para>A FILE_ALL_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_ALL_INFORMATION))]
		FileAllInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>19</para>
		/// <para>A FILE_ALLOCATION_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_ALLOCATION_INFORMATION))]
		FileAllocationInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>20</para>
		/// <para>A FILE_END_OF_FILE_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_END_OF_FILE_INFORMATION))]
		FileEndOfFileInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>21</para>
		/// <para>A FILE_NAME_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_NAME_INFORMATION))]
		FileAlternateNameInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>22</para>
		/// <para>A message buffer that contains one or more FILE_STREAM_INFORMATION structures.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_STREAM_INFORMATION))]
		FileStreamInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>23</para>
		/// <para>A FILE_PIPE_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_PIPE_INFORMATION))]
		FilePipeInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>24</para>
		/// <para>A FILE_PIPE_LOCAL_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_PIPE_LOCAL_INFORMATION))]
		FilePipeLocalInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>25</para>
		/// <para>A FILE_PIPE_REMOTE_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_PIPE_REMOTE_INFORMATION))]
		FilePipeRemoteInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>26</para>
		/// <para>A FILE_MAILSLOT_QUERY_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_MAILSLOT_QUERY_INFORMATION))]
		FileMailslotQueryInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>27</para>
		/// <para>A FILE_MAILSLOT_SET_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_MAILSLOT_SET_INFORMATION))]
		FileMailslotSetInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>28</para>
		/// <para>A FILE_COMPRESSION_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_COMPRESSION_INFORMATION))]
		FileCompressionInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>29</para>
		/// <para>A FILE_OBJECTID_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_OBJECTID_INFORMATION))]
		FileObjectIdInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>30</para>
		/// <para>This value is reserved for system use.</para>
		/// </summary>
		FileCompletionInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>31</para>
		/// <para>This value is reserved for system use.</para>
		/// </summary>
		FileMoveClusterInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>32</para>
		/// <para>A FILE_QUOTA_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_QUOTA_INFORMATION))]
		FileQuotaInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>33</para>
		/// <para>A FILE_REPARSE_POINT_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_REPARSE_POINT_INFORMATION))]
		FileReparsePointInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>34</para>
		/// <para>A FILE_NETWORK_OPEN_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_NETWORK_OPEN_INFORMATION))]
		FileNetworkOpenInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>35</para>
		/// <para>A FILE_ATTRIBUTE_TAG_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_ATTRIBUTE_TAG_INFORMATION))]
		FileAttributeTagInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>36</para>
		/// <para>This value is reserved for system use.</para>
		/// </summary>
		FileTrackingInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>37</para>
		/// <para>A FILE_ID_BOTH_DIR_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_ID_BOTH_DIR_INFORMATION))]
		FileIdBothDirectoryInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>38</para>
		/// <para>A FILE_ID_FULL_DIR_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_ID_FULL_DIR_INFORMATION))]
		FileIdFullDirectoryInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>39</para>
		/// <para>A FILE_VALID_DATA_LENGTH_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_VALID_DATA_LENGTH_INFORMATION))]
		FileValidDataLengthInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>40</para>
		/// <para>A FILE_NAME_INFORMATION structure.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_NAME_INFORMATION))]
		FileShortNameInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>41</para>
		/// <para>This value is reserved for system use. This value is available starting with Windows Vista.</para>
		/// </summary>
		FileIoCompletionNotificationInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>42</para>
		/// <para>This value is reserved for system use. This value is available starting with Windows Vista.</para>
		/// </summary>
		FileIoStatusBlockRangeInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>43</para>
		/// <para>A FILE_IO_PRIORITY_HINT_INFORMATION structure. This value is available starting with Windows Vista.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_IO_PRIORITY_HINT_INFORMATION))]
		FileIoPriorityHintInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>44</para>
		/// <para>This value is reserved for system use. This value is available starting with Windows Vista.</para>
		/// </summary>
		FileSfioReserveInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>45</para>
		/// <para>This value is reserved for system use. This value is available starting with Windows Vista.</para>
		/// </summary>
		FileSfioVolumeInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>46</para>
		/// <para>A FILE_LINKS_INFORMATION structure. This value is available starting with Windows Vista.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_LINKS_INFORMATION))]
		FileHardLinkInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>47</para>
		/// <para>
		/// FILE_PROCESS_IDS_USING_FILE_INFORMATION structure. This value is reserved for system use. This value is available starting with Windows Vista.
		/// </para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_PROCESS_IDS_USING_FILE_INFORMATION))]
		FileProcessIdsUsingFileInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>48</para>
		/// <para>A FILE_NAME_INFORMATION structure. This value is defined starting with Windows Vista. It is supported starting with Windows 8.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_NAME_INFORMATION))]
		FileNormalizedNameInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>49</para>
		/// <para>A FILE_NETWORK_PHYSICAL_NAME_INFORMATION structure. This value is available starting with Windows Vista.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_NETWORK_PHYSICAL_NAME_INFORMATION))]
		FileNetworkPhysicalNameInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>50</para>
		/// <para>A FILE_ID_GLOBAL_TX_DIR_INFORMATION structure. This value is available starting with Windows 7.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_ID_GLOBAL_TX_DIR_INFORMATION))]
		FileIdGlobalTxDirectoryInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>51</para>
		/// <para>
		/// FILE_IS_REMOTE_DEVICE_INFORMATION structure. This value is reserved for system use. This value is available starting with Windows 7.
		/// </para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_IS_REMOTE_DEVICE_INFORMATION))]
		FileIsRemoteDeviceInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>52</para>
		/// <para>This value is reserved for system use. This value is available starting with Windows 7.</para>
		/// </summary>
		FileUnusedInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>53</para>
		/// <para>FILE_NUMA_NODE_INFORMATION structure. This value is reserved for system use. This value is available starting with Windows 7.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_NUMA_NODE_INFORMATION))]
		FileNumaNodeInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>54</para>
		/// <para>
		/// FILE_STANDARD_LINK_INFORMATION structure. This value is reserved for system use. This value is available starting with Windows 7.
		/// </para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_STANDARD_LINK_INFORMATION))]
		FileStandardLinkInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>55</para>
		/// <para>A FILE_REMOTE_PROTOCOL_INFORMATION structure. This value is available starting with Windows 7.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_REMOTE_PROTOCOL_INFORMATION))]
		FileRemoteProtocolInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>56</para>
		/// <para>
		/// A <b>FILE_RENAME_INFORMATION</b> structure. This is a special version of the FileRenameInformation operation that is used by
		/// kernel-mode drivers only in order to bypass security access checks. This operation is only recognized by the IOManager and a
		/// file system should never receive it. This value is available starting with Windows 10.
		/// </para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_RENAME_INFORMATION))]
		FileRenameInformationBypassAccessCheck,

		/// <summary>
		/// <para>Value:</para>
		/// <para>57</para>
		/// <para>
		/// A <b>FILE_LINK_INFORMATION</b> structure. This is a special version of the FileLinkInformation operation that is used by
		/// kernel-mode drivers only in order to bypass security access checks. This operation is only recognized by the IOManager and a
		/// file system should never receive it. This value is available starting with Windows 10.
		/// </para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_LINK_INFORMATION))]
		FileLinkInformationBypassAccessCheck,

		/// <summary>
		/// <para>Value:</para>
		/// <para>58</para>
		/// <para>FILE_VOLUME_NAME_INFORMATION structure. This value is reserved for system use. This value is available starting with Windows 10.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_VOLUME_NAME_INFORMATION))]
		FileVolumeNameInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>59</para>
		/// <para>FILE_ID_INFORMATION structure. This value is reserved for system use. This value is available starting with Windows 10.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_ID_INFORMATION))]
		FileIdInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>60</para>
		/// <para>FILE_ID_EXTD_DIR_INFORMATION structure. This value is reserved for system use. This value is available starting with Windows 10.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_ID_EXTD_DIR_INFORMATION))]
		FileIdExtdDirectoryInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>61</para>
		/// <para>
		/// A FILE_COMPLETION_INFORMATION structure to change or remove the completion port associated with a file handle. This value is
		/// available starting with Windows 8.1.
		/// </para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_COMPLETION_INFORMATION))]
		FileReplaceCompletionInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>62</para>
		/// <para>
		/// FILE_LINKS_FULL_ID_INFORMATION structure. This value is reserved for system use. This value is available starting with Windows 10.
		/// </para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_LINKS_FULL_ID_INFORMATION))]
		FileHardLinkFullIdInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>63</para>
		/// <para>
		/// FILE_ID_EXTD_BOTH_DIR_INFORMATION structure. This value is reserved for system use. This value is available starting with Windows 10.
		/// </para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_ID_EXTD_BOTH_DIR_INFORMATION))]
		FileIdExtdBothDirectoryInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>64</para>
		/// <para>
		/// A FILE_DISPOSITION_INFORMATION_EX structure that indicates how the operating system should delete a file. This value is
		/// available starting with Windows 10, version 1709.
		/// </para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_DISPOSITION_INFORMATION_EX))]
		FileDispositionInformationEx,

		/// <summary>
		/// <para>Value:</para>
		/// <para>65</para>
		/// <para>
		/// A FILE_RENAME_INFORMATION structure which contains additional flags. This value is available starting with Windows 10, version 1709.
		/// </para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_RENAME_INFORMATION))]
		FileRenameInformationEx,

		/// <summary>
		/// <para>Value:</para>
		/// <para>66</para>
		/// <para>
		/// A <strong>FILE_RENAME_INFORMATION</strong> structure which contains additional flags. This value is available starting with
		/// Windows 10, version 1709. This is a special version of the FileRenameInformation operation that is used by kernel-mode drivers
		/// only in order to bypass security access checks. This operation is only recognized by the IOManager and a file system should
		/// never receive it.
		/// </para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_RENAME_INFORMATION))]
		FileRenameInformationExBypassAccessCheck,

		/// <summary>
		/// <para>Value:</para>
		/// <para>67</para>
		/// <para>
		/// A FILE_DESIRED_STORAGE_CLASS_INFORMATION structure, declared in ntifs.h. This value is available starting with Windows 10,
		/// version 1709.
		/// </para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_DESIRED_STORAGE_CLASS_INFORMATION))]
		FileDesiredStorageClassInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>68</para>
		/// <para>A FILE_STAT_INFORMATION structure, declared in ntifs.h. This value is available starting with Windows 10, version 1709.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_STAT_INFORMATION))]
		FileStatInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>69</para>
		/// <para>Reserved. This value is available starting with Windows 10, version 1709.</para>
		/// </summary>
		FileMemoryPartitionInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>70</para>
		/// <para>
		/// A FILE_STAT_LX_INFORMATION structure, declared in ntifs.h. This information class is used for fields refer to Linux metadata
		/// used/created by the Windows Subsystem for Linux. This value is available starting with Windows 10 April 2018 Update.
		/// </para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_STAT_LX_INFORMATION))]
		FileStatLxInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>71</para>
		/// <para>
		/// A FILE_CASE_SENSITIVE_INFORMATION structure, declared in ntifs.h. This value is available starting with Windows 10 April 2018 Update.
		/// </para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_CASE_SENSITIVE_INFORMATION))]
		FileCaseSensitiveInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>72</para>
		/// <para>
		/// A FILE_LINK_INFORMATION structure which contains additional flags. This value is available starting with Windows 10, version 1809.
		/// </para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_LINK_INFORMATION))]
		FileLinkInformationEx,

		/// <summary>
		/// <para>Value:</para>
		/// <para>73</para>
		/// <para>
		/// A <strong>FILE_LINK_INFORMATION</strong> structure which contains additional flags. This is a special version of the
		/// FileLinkInformation operation that is used by kernel-mode drivers only in order to bypass security access checks. This operation
		/// is only recognized by the IOManager and a file system should never receive it. This value is available starting with Windows 10,
		/// version 1809.
		/// </para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_LINK_INFORMATION))]
		FileLinkInformationExBypassAccessCheck,

		/// <summary>
		/// <para>Value:</para>
		/// <para>74</para>
		/// <para>
		/// A FILE_SET_STORAGE_RESERVE_ID_INFORMATION structure, declared in ntifs.h. This value is available starting with Windows 10,
		/// version 1809.
		/// </para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_SET_STORAGE_RESERVE_ID_INFORMATION))]
		FileStorageReserveIdInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>75</para>
		/// <para>
		/// A <strong>FILE_CASE_SENSITIVE_INFORMATION</strong> structure, declared in ntifs.h. This is a special version of the
		/// FileCaseSensitiveInformation operation that is used to force the IOManager to perform access checks for the kernel-mode driver,
		/// similar to the checks that apply to a user-mode caller. This operation is only recognized by the IOManager and a file system
		/// should never receive it. This value is available starting with Windows 10, version 1809.
		/// </para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_CASE_SENSITIVE_INFORMATION))]
		FileCaseSensitiveInformationForceAccessCheck,

		/// <summary>
		/// <para>Value:</para>
		/// <para>76</para>
		/// <para>A FILE_KNOWN_FOLDER_INFORMATION structure, declared in ntifs.h. This value is available starting with Windows Server 2022.</para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_KNOWN_FOLDER_INFORMATION))]
		FileKnownFolderInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>77</para>
		/// <para>
		/// A FILE_STAT_BASIC_INFORMATION structure, declared in ntifs.h. This value is available starting with Windows 11, build 26048.
		/// </para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_STAT_BASIC_INFORMATION))]
		FileStatBasicInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>78</para>
		/// <para>
		/// A FILE_ID_64_EXTD_DIR_INFORMATION structure, declared in ntifs.h. This value is available starting with Windows 11, version 23H2.
		/// </para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_ID_64_EXTD_DIR_INFORMATION))]
		FileId64ExtdDirectoryInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>79</para>
		/// <para>
		/// A FILE_ID_64_EXTD_BOTH_DIR_INFORMATION structure, declared in ntifs.h. This value is available starting with Windows 11, version 23H2.
		/// </para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_ID_64_EXTD_BOTH_DIR_INFORMATION))]
		FileId64ExtdBothDirectoryInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>80</para>
		/// <para>
		/// A FILE_ID_ALL_EXTD_DIR_INFORMATION structure, declared in ntifs.h. This value is available starting with Windows 11, version 23H2.
		/// </para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_ID_ALL_EXTD_DIR_INFORMATION))]
		FileIdAllExtdDirectoryInformation,

		/// <summary>
		/// <para>Value:</para>
		/// <para>81</para>
		/// <para>
		/// A FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION structure, declared in ntifs.h. This value is available starting with Windows 11,
		/// version 23H2.
		/// </para>
		/// </summary>
		//[CorrespondingType(typeof(FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION))]
		FileIdAllExtdBothDirectoryInformation,

		/// <summary>The file stream reservation information</summary>
		FileStreamReservationInformation,

		/// <summary>The file mup provider information</summary>
		FileMupProviderInfo,
	}

	/// <summary>
	/// <para>The <c>KEY_INFORMATION_CLASS</c> enumeration type represents the type of information to supply about a registry key.</para>
	/// </summary>
	/// <remarks>
	/// <para>
	/// Use the <c>KEY_INFORMATION_CLASS</c> values to specify the type of data to be supplied by the ZwEnumerateKey and ZwQueryKey routines.
	/// </para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/ne-wdm-_key_information_class typedef enum
	// _KEY_INFORMATION_CLASS { KeyBasicInformation , KeyNodeInformation , KeyFullInformation , KeyNameInformation , KeyCachedInformation ,
	// KeyFlagsInformation , KeyVirtualizationInformation , KeyHandleTagsInformation , KeyTrustInformation , KeyLayerInformation ,
	// MaxKeyInfoClass } KEY_INFORMATION_CLASS;
	[PInvokeData("wdm.h", MSDNShortId = "cb531a0e-c934-4f3e-9b92-07eb3ab75673")]
	public enum KEY_INFORMATION_CLASS : uint
	{
		/// <summary>A KEY_BASIC_INFORMATION structure is supplied.</summary>
		[CorrespondingType(typeof(KEY_BASIC_INFORMATION))]
		KeyBasicInformation,

		/// <summary>A KEY_NODE_INFORMATION structure is supplied.</summary>
		[CorrespondingType(typeof(KEY_NODE_INFORMATION))]
		KeyNodeInformation,

		/// <summary>A KEY_FULL_INFORMATION structure is supplied.</summary>
		[CorrespondingType(typeof(KEY_FULL_INFORMATION))]
		KeyFullInformation,

		/// <summary>A KEY_NAME_INFORMATION structure is supplied.</summary>
		[CorrespondingType(typeof(KEY_NAME_INFORMATION))]
		KeyNameInformation,

		/// <summary>A KEY_CACHED_INFORMATION structure is supplied.</summary>
		KeyCachedInformation,

		/// <summary>Reserved for system use.</summary>
		KeyFlagsInformation,

		/// <summary>A KEY_VIRTUALIZATION_INFORMATION structure is supplied.</summary>
		KeyVirtualizationInformation,

		/// <summary>Reserved for system use.</summary>
		KeyHandleTagsInformation,

		/// <summary/>
		KeyTrustInformation,

		/// <summary/>
		KeyLayerInformation,

		/// <summary>The maximum value in this enumeration type.</summary>
		MaxKeyInfoClass,
	}

	/// <summary>
	/// <para>The <c>DbgBreakPoint</c> routine breaks into the kernel debugger.</para>
	/// </summary>
	/// <returns>
	/// <para>None</para>
	/// </returns>
	/// <remarks>
	/// <para>The <c>DbgBreakPoint</c> routine is the kernel-mode equivalent of <c>DebugBreak</c>.</para>
	/// <para>
	/// This routine raises an exception that is handled by the kernel debugger if one is installed; otherwise, it is handled by the debug
	/// system. If a debugger is not connected to the system, the exception can be handled in the standard way.
	/// </para>
	/// <para>
	/// In kernel mode, a break exception that is not handled will cause a bug check. You can, however, connect a kernel-mode debugger to a
	/// target computer that has stopped responding and has kernel debugging enabled. For more information, see Windows Debugging.
	/// </para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-dbgbreakpoint __analysis_noreturn VOID
	// DbgBreakPoint( );
	[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true)]
	[PInvokeData("wdm.h", MSDNShortId = "deeac910-2cc3-4a54-bf3b-aeb56d0004dc")]
	public static extern void DbgBreakPoint();

	/// <summary>
	/// <para>The <c>DbgPrint</c> routine sends a message to the kernel debugger.</para>
	/// <para>
	/// In Windows Vista and later versions of Windows, <c>DbgPrint</c> sends a message only when the conditions that you specify apply (see
	/// the <a href="#remarks">Remarks</a> section for information).
	/// </para>
	/// </summary>
	/// <param name="Format">
	/// <para>
	/// Specifies a pointer to the format string to print. The Format string supports most of the printf-style format specification fields.
	/// However, the Unicode format codes (%C, %S, %lc, %ls, %wc, %ws, and %wZ) can only be used with IRQL = PASSIVE_LEVEL. The
	/// <c>DbgPrint</c> routine does not support any of the floating point types (%f, %e, %E, %g, %G, %a, or %A).
	/// </para>
	/// </param>
	/// <param name="arguments">
	/// <para>Specifies arguments for the format string, as in <c>printf</c>.</para>
	/// </param>
	/// <returns>
	/// <para>If successful, <c>DbgPrint</c> returns the NTSTATUS code STATUS_SUCCESS; otherwise it returns the appropriate error code.</para>
	/// </returns>
	/// <remarks>
	/// <para>
	/// <c>DbgPrint</c> and <c>DbgPrintEx</c> can be called at IRQL&lt;=DIRQL. However, Unicode format codes (%wc and %ws) can be used only
	/// at IRQL=PASSIVE_LEVEL. Also, because the debugger uses interprocess interrupts (IPIs) to communicate with other processors, calling
	/// <c>DbgPrint</c> at IRQL&gt;DIRQL can cause deadlocks.
	/// </para>
	/// <para>Only kernel-mode drivers can call the <c>DbgPrint</c> routine.</para>
	/// <para>
	/// In Microsoft Windows Server 2003 and earlier versions of Windows, the <c>DbgPrint</c> routine sends a message to the kernel
	/// debugger. In Windows Vista and later versions of Windows, <c>DbgPrint</c> sends a message only if certain conditions apply.
	/// Specifically, it behaves like the DbgPrintEx routine with the DEFAULT component and a message importance level of DPFLTR_INFO_LEVEL.
	/// <code>
	///DbgPrint ( Format, arguments ),
	///DbgPrintEx ( DPFLTR_DEFAULT_ID, DPFLTR_INFO_LEVEL, Format, arguments )
	/// </code>
	/// </para>
	/// <para>
	/// For more information about message filtering, components, and message importance level, see Reading and Filtering Debugging Messages.
	/// </para>
	/// <para>
	/// Regardless of which version of Windows you are using, it is recommended that you use <c>DbgPrintEx</c> instead of <c>DbgPrint</c>,
	/// since this allows you to control the conditions under which the message is sent.
	/// </para>
	/// <para>
	/// Unless it is absolutely necessary, you should not obtain a string from user input or another process and pass it to <c>DbgPrint</c>.
	/// If you do use a string that you did not create, you must verify that this is a valid format string, and that the format codes match
	/// the argument list in type and quantity. The best coding practice is for all Format strings to be static and defined at compile time.
	/// </para>
	/// <para>
	/// There is no upper limit to the size of the Format string or the number of arguments. However, any single call to <c>DbgPrint</c>
	/// will only transmit 512 bytes of information. There is also a limit to the size of the <c>DbgPrint</c> buffer. See DbgPrint Buffer
	/// and the Debugger for details.
	/// </para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/nf-wdm-dbgprint ULONG DbgPrint([in] PCSTR Format,...);
	[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true)]
	[PInvokeData("wdm.h", MSDNShortId = "NF:wdm.DbgPrint")]
	public static extern NTStatus DbgPrint([MarshalAs(UnmanagedType.LPStr)] string Format, [In] IntPtr arguments);

	/// <summary>
	/// <para>The <c>DbgPrint</c> routine sends a message to the kernel debugger.</para>
	/// <para>
	/// In Windows Vista and later versions of Windows, <c>DbgPrint</c> sends a message only when the conditions that you specify apply (see
	/// the Remarks section for information).
	/// </para>
	/// </summary>
	/// <param name="Format">
	/// Specifies a pointer to the format string to print. The <c>Format</c> string supports most of the <c>printf</c>-style format
	/// specification fields. However, the Unicode format codes ( <c>%C</c>, <c>%S</c>, <c>%lc</c>, <c>%ls</c>, <c>%wc</c>, <c>%ws</c>, and
	/// <c>%wZ</c>) can only be used with IRQL = PASSIVE_LEVEL. The <c>DbgPrint</c> routine does not support any of the floating point types
	/// ( <c>%f</c>, <c>%e</c>, <c>%E</c>, <c>%g</c>, <c>%G</c>, <c>%a</c>, or <c>%A</c>).
	/// </param>
	/// <param name="args">Specifies arguments for the format string, as in <c>printf</c>.</param>
	/// <returns>
	/// If successful, <c>DbgPrint</c> returns the NTSTATUS code STATUS_SUCCESS; otherwise it returns the appropriate error code.
	/// </returns>
	/// <remarks>
	/// <para>
	/// <c>DbgPrint</c> and <c>DbgPrintEx</c> can be called at IRQL&lt;=DIRQL. However, Unicode format codes (%wc and %ws) can be used only
	/// at IRQL=PASSIVE_LEVEL. Also, because the debugger uses interprocess interrupts (IPIs) to communicate with other processors, calling
	/// <c>DbgPrint</c> at IRQL&gt;DIRQL can cause deadlocks.
	/// </para>
	/// <para>Only kernel-mode drivers can call the <c>DbgPrint</c> routine.</para>
	/// <para>
	/// In Microsoft Windows Server 2003 and earlier versions of Windows, the <c>DbgPrint</c> routine sends a message to the kernel
	/// debugger. In Windows Vista and later versions of Windows, <c>DbgPrint</c> sends a message only if certain conditions apply.
	/// Specifically, it behaves like the DbgPrintEx routine with the DEFAULT component and a message importance level of DPFLTR_INFO_LEVEL.
	/// In other words, the following two function calls are identical:
	/// </para>
	/// <para>
	/// <code>DbgPrint ( Format, arguments ) DbgPrintEx ( DPFLTR_DEFAULT_ID, DPFLTR_INFO_LEVEL, Format, arguments )</code>
	/// </para>
	/// <para>
	/// For more information about message filtering, components, and message importance level, see Reading and Filtering Debugging Messages.
	/// </para>
	/// <para>
	/// <c>Note</c> Regardless of which version of Windows you are using, it is recommended that you use <c>DbgPrintEx</c> instead of
	/// <c>DbgPrint</c>, since this allows you to control the conditions under which the message is sent.
	/// </para>
	/// <para>
	/// Unless it is absolutely necessary, you should not obtain a string from user input or another process and pass it to <c>DbgPrint</c>.
	/// If you do use a string that you did not create, you must verify that this is a valid format string, and that the format codes match
	/// the argument list in type and quantity. The best coding practice is for all <c>Format</c> strings to be static and defined at
	/// compile time.
	/// </para>
	/// <para>
	/// There is no upper limit to the size of the <c>Format</c> string or the number of arguments. However, any single call to
	/// <c>DbgPrint</c> will only transmit 512 bytes of information. There is also a limit to the size of the DbgPrint buffer. See DbgPrint
	/// Buffer and the Debugger for details.
	/// </para>
	/// </remarks>
	[PInvokeData("wdm.h", MSDNShortId = "NF:wdm.DbgPrintEx")]
	public static NTStatus DbgPrint(string Format, params object[] args)
	{
		using var pargs = new SafeHGlobalHandle(InteropExtensions.MarshalObjectsToPtr(args, Marshal.AllocHGlobal, out var sz, true), sz, true);
		return DbgPrint(Format, pargs);
	}

	/// <summary>The <c>DbgPrintEx</c> routine sends a string to the kernel debugger if the conditions you specify are met.</summary>
	/// <param name="ComponentId">
	/// <para>
	/// Specifies the component calling this routine. This must be one of the component name filter IDs defined in the Dpfilter.h header
	/// file. To avoid mixing your driver's output with the output of Windows components, you should use only the following values for <c>ComponentId</c>:
	/// </para>
	/// <list type="bullet">
	/// <item>
	/// <term>DPFLTR_IHVVIDEO_ID</term>
	/// </item>
	/// <item>
	/// <term>DPFLTR_IHVAUDIO_ID</term>
	/// </item>
	/// <item>
	/// <term>DPFLTR_IHVNETWORK_ID</term>
	/// </item>
	/// <item>
	/// <term>DPFLTR_IHVSTREAMING_ID</term>
	/// </item>
	/// <item>
	/// <term>DPFLTR_IHVBUS_ID</term>
	/// </item>
	/// <item>
	/// <term>DPFLTR_IHVDRIVER_ID</term>
	/// </item>
	/// </list>
	/// </param>
	/// <param name="Level">
	/// Specifies the severity of the message being sent. This can be any 32-bit integer. Values between 0 and 31 (inclusive) are treated
	/// differently than values between 32 and 0xFFFFFFFF. For details, see Reading and Filtering Debugging Messages.
	/// </param>
	/// <param name="Format">
	/// Specifies a pointer to the format string to print. The <c>Format</c> string supports most of the <c>printf</c>-style format
	/// specification fields. However, the Unicode format codes ( <c>%C</c>, <c>%S</c>, <c>%lc</c>, <c>%ls</c>, <c>%wc</c>, <c>%ws</c>, and
	/// <c>%wZ</c>) can only be used with IRQL = PASSIVE_LEVEL. The <c>DbgPrintEx</c> routine does not support any of the floating point
	/// types ( <c>%f</c>, <c>%e</c>, <c>%E</c>, <c>%g</c>, <c>%G</c>, <c>%a</c>, or <c>%A</c>).
	/// </param>
	/// <param name="arguments">Specifies arguments for the format string, as in <c>printf</c>.</param>
	/// <returns>
	/// If successful, <c>DbgPrintEx</c> returns the NTSTATUS code STATUS_SUCCESS; otherwise, it returns the appropriate error code.
	/// </returns>
	/// <remarks>
	/// <para>Only kernel-mode drivers can call the <c>DbgPrintEx</c> routine.</para>
	/// <para>
	/// <c>DbgPrint</c> and <c>DbgPrintEx</c> can be called at IRQL&lt;=DIRQL. However, Unicode format codes ( <c>%wc</c> and <c>%ws</c>)
	/// can be used only at IRQL = PASSIVE_LEVEL. Also, because the debugger uses interprocess interrupts (IPIs) to communicate with other
	/// processors, calling <c>DbgPrint</c> at IRQL&gt;DIRQL can cause deadlocks.
	/// </para>
	/// <para>
	/// <c>DbgPrintEx</c> either passes the specified string to the kernel debugger or does nothing at all, depending on the values of
	/// <c>ComponentId</c>, <c>Level</c>, and the corresponding component filter masks. For details, see Reading and Filtering Debugging Messages.
	/// </para>
	/// <para>
	/// Unless it is absolutely necessary, you should not obtain a string from user input or another process and pass it to
	/// <c>DbgPrintEx</c>. If you do use a string that you did not create, you must verify that this is a valid format string, and that the
	/// format codes match the argument list in type and quantity. The best coding practice is for all <c>Format</c> strings to be static
	/// and defined at compile time.
	/// </para>
	/// <para>
	/// There is no upper limit to the size of the <c>Format</c> string or the number of arguments. However, any single call to
	/// <c>DbgPrintEx</c> will only transmit 512 bytes of information. There is also a limit to the size of the DbgPrint buffer. See The
	/// DbgPrint Buffer and the Debugger for details.
	/// </para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/nf-wdm-dbgprintex NTSYSAPI ULONG DbgPrintEx([in] ULONG ComponentId,
	// [in] ULONG Level,[in] PCSTR Format,...);
	[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true)]
	[PInvokeData("wdm.h", MSDNShortId = "NF:wdm.DbgPrintEx")]
	public static extern NTStatus DbgPrintEx(DPFLTR_TYPE ComponentId, uint Level, [MarshalAs(UnmanagedType.LPStr)] string Format, [In] IntPtr arguments);

	/// <summary>The <c>DbgPrintEx</c> routine sends a string to the kernel debugger if the conditions you specify are met.</summary>
	/// <param name="ComponentId">
	/// <para>
	/// Specifies the component calling this routine. This must be one of the component name filter IDs defined in the Dpfilter.h header
	/// file. To avoid mixing your driver's output with the output of Windows components, you should use only the following values for <c>ComponentId</c>:
	/// </para>
	/// <list type="bullet">
	/// <item>
	/// <term>DPFLTR_IHVVIDEO_ID</term>
	/// </item>
	/// <item>
	/// <term>DPFLTR_IHVAUDIO_ID</term>
	/// </item>
	/// <item>
	/// <term>DPFLTR_IHVNETWORK_ID</term>
	/// </item>
	/// <item>
	/// <term>DPFLTR_IHVSTREAMING_ID</term>
	/// </item>
	/// <item>
	/// <term>DPFLTR_IHVBUS_ID</term>
	/// </item>
	/// <item>
	/// <term>DPFLTR_IHVDRIVER_ID</term>
	/// </item>
	/// </list>
	/// </param>
	/// <param name="Level">
	/// Specifies the severity of the message being sent. This can be any 32-bit integer. Values between 0 and 31 (inclusive) are treated
	/// differently than values between 32 and 0xFFFFFFFF. For details, see Reading and Filtering Debugging Messages.
	/// </param>
	/// <param name="Format">
	/// Specifies a pointer to the format string to print. The <c>Format</c> string supports most of the <c>printf</c>-style format
	/// specification fields. However, the Unicode format codes ( <c>%C</c>, <c>%S</c>, <c>%lc</c>, <c>%ls</c>, <c>%wc</c>, <c>%ws</c>, and
	/// <c>%wZ</c>) can only be used with IRQL = PASSIVE_LEVEL. The <c>DbgPrintEx</c> routine does not support any of the floating point
	/// types ( <c>%f</c>, <c>%e</c>, <c>%E</c>, <c>%g</c>, <c>%G</c>, <c>%a</c>, or <c>%A</c>).
	/// </param>
	/// <param name="args">Specifies arguments for the format string, as in <c>printf</c>.</param>
	/// <returns>
	/// If successful, <c>DbgPrintEx</c> returns the NTSTATUS code STATUS_SUCCESS; otherwise, it returns the appropriate error code.
	/// </returns>
	/// <remarks>
	/// <para>Only kernel-mode drivers can call the <c>DbgPrintEx</c> routine.</para>
	/// <para>
	/// <c>DbgPrint</c> and <c>DbgPrintEx</c> can be called at IRQL&lt;=DIRQL. However, Unicode format codes ( <c>%wc</c> and <c>%ws</c>)
	/// can be used only at IRQL = PASSIVE_LEVEL. Also, because the debugger uses interprocess interrupts (IPIs) to communicate with other
	/// processors, calling <c>DbgPrint</c> at IRQL&gt;DIRQL can cause deadlocks.
	/// </para>
	/// <para>
	/// <c>DbgPrintEx</c> either passes the specified string to the kernel debugger or does nothing at all, depending on the values of
	/// <c>ComponentId</c>, <c>Level</c>, and the corresponding component filter masks. For details, see Reading and Filtering Debugging Messages.
	/// </para>
	/// <para>
	/// Unless it is absolutely necessary, you should not obtain a string from user input or another process and pass it to
	/// <c>DbgPrintEx</c>. If you do use a string that you did not create, you must verify that this is a valid format string, and that the
	/// format codes match the argument list in type and quantity. The best coding practice is for all <c>Format</c> strings to be static
	/// and defined at compile time.
	/// </para>
	/// <para>
	/// There is no upper limit to the size of the <c>Format</c> string or the number of arguments. However, any single call to
	/// <c>DbgPrintEx</c> will only transmit 512 bytes of information. There is also a limit to the size of the DbgPrint buffer. See The
	/// DbgPrint Buffer and the Debugger for details.
	/// </para>
	/// </remarks>
	[PInvokeData("wdm.h", MSDNShortId = "NF:wdm.DbgPrintEx")]
	public static NTStatus DbgPrintEx(DPFLTR_TYPE ComponentId, uint Level, string Format, params object[] args)
	{
		using var pargs = new SafeHGlobalHandle(InteropExtensions.MarshalObjectsToPtr(args, Marshal.AllocHGlobal, out var sz, true), sz, true);
		return DbgPrintEx(ComponentId, Level, Format, pargs);
	}

	/// <summary>
	/// <para>
	/// The <c>ZwCommitComplete</c> routine notifies KTM that the calling resource manager has finished committing a transaction's data.
	/// </para>
	/// </summary>
	/// <param name="EnlistmentHandle">
	/// <para>
	/// A handle to an enlistment object that was obtained by a previous call to ZwCreateEnlistment or ZwOpenEnlistment. The handle must
	/// have ENLISTMENT_SUBORDINATE_RIGHTS access to the object.
	/// </para>
	/// </param>
	/// <param name="TmVirtualClock">
	/// <para>A pointer to a virtual clock value. This parameter is optional and can be <c>NULL</c>.</para>
	/// </param>
	/// <returns>
	/// <para>
	/// <c>ZwCommitComplete</c> returns STATUS_SUCCESS if the operation succeeds. Otherwise, this routine might return one of the following values:
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>Return code</term>
	/// <term>Description</term>
	/// </listheader>
	/// <item>
	/// <term>STATUS_OBJECT_TYPE_MISMATCH</term>
	/// <term>The specified handle is not a handle to an enlistment object.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_INVALID_HANDLE</term>
	/// <term>The object handle is invalid.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_ACCESS_DENIED</term>
	/// <term>The caller does not have appropriate access to the enlistment object.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_TRANSACTION_NOT_REQUESTED</term>
	/// <term>The transaction or its enlistment is not in the correct state.</term>
	/// </item>
	/// </list>
	/// <para>The routine might return other NTSTATUS values.</para>
	/// </returns>
	/// <remarks>
	/// <para>A resource manager must call <c>ZwCommitComplete</c> after it has finished servicing a TRANSACTION_NOTIFY_COMMIT notification.</para>
	/// <para>For more information about <c>ZwCommitComplete</c>, see Handling Commit Operations.</para>
	/// <para>
	/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
	/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship between
	/// the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
	/// </para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-ntcommitcomplete __kernel_entry NTSYSCALLAPI
	// NTSTATUS NtCommitComplete( HANDLE EnlistmentHandle, PLARGE_INTEGER TmVirtualClock );
	[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true)]
	[PInvokeData("wdm.h", MSDNShortId = "d0b968bc-bbab-4b6f-bb1f-9e36ac7c1e05")]
	public static extern NTStatus NtCommitComplete([In] SafeEnlistmentHandle EnlistmentHandle, in long TmVirtualClock);

	/// <summary>
	/// <para>
	/// The <c>ZwCommitComplete</c> routine notifies KTM that the calling resource manager has finished committing a transaction's data.
	/// </para>
	/// </summary>
	/// <param name="EnlistmentHandle">
	/// <para>
	/// A handle to an enlistment object that was obtained by a previous call to ZwCreateEnlistment or ZwOpenEnlistment. The handle must
	/// have ENLISTMENT_SUBORDINATE_RIGHTS access to the object.
	/// </para>
	/// </param>
	/// <param name="TmVirtualClock">
	/// <para>A pointer to a virtual clock value. This parameter is optional and can be <c>NULL</c>.</para>
	/// </param>
	/// <returns>
	/// <para>
	/// <c>ZwCommitComplete</c> returns STATUS_SUCCESS if the operation succeeds. Otherwise, this routine might return one of the following values:
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>Return code</term>
	/// <term>Description</term>
	/// </listheader>
	/// <item>
	/// <term>STATUS_OBJECT_TYPE_MISMATCH</term>
	/// <term>The specified handle is not a handle to an enlistment object.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_INVALID_HANDLE</term>
	/// <term>The object handle is invalid.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_ACCESS_DENIED</term>
	/// <term>The caller does not have appropriate access to the enlistment object.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_TRANSACTION_NOT_REQUESTED</term>
	/// <term>The transaction or its enlistment is not in the correct state.</term>
	/// </item>
	/// </list>
	/// <para>The routine might return other NTSTATUS values.</para>
	/// </returns>
	/// <remarks>
	/// <para>A resource manager must call <c>ZwCommitComplete</c> after it has finished servicing a TRANSACTION_NOTIFY_COMMIT notification.</para>
	/// <para>For more information about <c>ZwCommitComplete</c>, see Handling Commit Operations.</para>
	/// <para>
	/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
	/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship between
	/// the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
	/// </para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-ntcommitcomplete __kernel_entry NTSYSCALLAPI
	// NTSTATUS NtCommitComplete( HANDLE EnlistmentHandle, PLARGE_INTEGER TmVirtualClock );
	[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true)]
	[PInvokeData("wdm.h", MSDNShortId = "d0b968bc-bbab-4b6f-bb1f-9e36ac7c1e05")]
	public static extern NTStatus NtCommitComplete([In] SafeEnlistmentHandle EnlistmentHandle, [In, Optional] IntPtr TmVirtualClock);

	/// <summary>
	/// <para>The <c>ZwCommitEnlistment</c> routine initiates the commit operation for a specified enlistment's transaction.</para>
	/// </summary>
	/// <param name="EnlistmentHandle">
	/// <para>
	/// A handle to an enlistment object that was obtained by a previous call to ZwCreateEnlistment or ZwOpenEnlistment. The object must
	/// represent a superior enlistment and the handle must have ENLISTMENT_SUPERIOR_RIGHTS access to the object.
	/// </para>
	/// </param>
	/// <param name="TmVirtualClock">
	/// <para>A pointer to a virtual clock value. This parameter is optional and can be <c>NULL</c>.</para>
	/// </param>
	/// <returns>
	/// <para>
	/// <c>ZwCommitEnlistment</c> returns STATUS_SUCCESS if the operation succeeds. Otherwise, this routine might return one of the
	/// following values:
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>Return code</term>
	/// <term>Description</term>
	/// </listheader>
	/// <item>
	/// <term>STATUS_OBJECT_TYPE_MISMATCH</term>
	/// <term>The specified handle is not a handle to an enlistment object.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_INVALID_HANDLE</term>
	/// <term>The object handle is invalid.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_ACCESS_DENIED</term>
	/// <term>The caller does not have appropriate access to the enlistment object.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_ENLISTMENT_NOT_SUPERIOR</term>
	/// <term>The caller is not a superior transaction manager for the enlistment.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED</term>
	/// <term>The caller did not register to receive TRANSACTION_NOTIFY_COMMIT_COMPLETE notifications.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_TRANSACTION_REQUEST_NOT_VALID</term>
	/// <term>The enlistment's transaction is not in a state that allows it to be committed.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_TRANSACTION_NOT_ACTIVE</term>
	/// <term>The commit operation for this transaction has already been started.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_TRANSACTION_ALREADY_ABORTED</term>
	/// <term>The transaction cannot be committed because it has been rolled back.</term>
	/// </item>
	/// </list>
	/// <para>The routine might return other NTSTATUS values.</para>
	/// </returns>
	/// <remarks>
	/// <para>Only superior transaction managers can call <c>ZwCommitEnlistment</c>.</para>
	/// <para>Callers of <c>ZwCommitEnlistment</c> must register to receive TRANSACTION_NOTIFY_COMMIT_COMPLETE notifications.</para>
	/// <para>
	/// The <c>ZwCommitEnlistment</c> routine causes KTM to send TRANSACTION_NOTIFY_COMMIT notifications to all resource managers that have
	/// enlisted in the transaction.
	/// </para>
	/// <para>For more information about <c>ZwCommitEnlistment</c>, see Creating a Superior Transaction Manager and Handling Commit Operations.</para>
	/// <para>
	/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
	/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship between
	/// the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
	/// </para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-ntcommitenlistment __kernel_entry NTSYSCALLAPI
	// NTSTATUS NtCommitEnlistment( HANDLE EnlistmentHandle, PLARGE_INTEGER TmVirtualClock );
	[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true)]
	[PInvokeData("wdm.h", MSDNShortId = "9c7f3e24-1d7c-450e-bbef-df0479911bc6")]
	public static extern NTStatus NtCommitEnlistment([In] SafeEnlistmentHandle EnlistmentHandle, in long TmVirtualClock);

	/// <summary>
	/// <para>The <c>ZwCommitEnlistment</c> routine initiates the commit operation for a specified enlistment's transaction.</para>
	/// </summary>
	/// <param name="EnlistmentHandle">
	/// <para>
	/// A handle to an enlistment object that was obtained by a previous call to ZwCreateEnlistment or ZwOpenEnlistment. The object must
	/// represent a superior enlistment and the handle must have ENLISTMENT_SUPERIOR_RIGHTS access to the object.
	/// </para>
	/// </param>
	/// <param name="TmVirtualClock">
	/// <para>A pointer to a virtual clock value. This parameter is optional and can be <c>NULL</c>.</para>
	/// </param>
	/// <returns>
	/// <para>
	/// <c>ZwCommitEnlistment</c> returns STATUS_SUCCESS if the operation succeeds. Otherwise, this routine might return one of the
	/// following values:
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>Return code</term>
	/// <term>Description</term>
	/// </listheader>
	/// <item>
	/// <term>STATUS_OBJECT_TYPE_MISMATCH</term>
	/// <term>The specified handle is not a handle to an enlistment object.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_INVALID_HANDLE</term>
	/// <term>The object handle is invalid.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_ACCESS_DENIED</term>
	/// <term>The caller does not have appropriate access to the enlistment object.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_ENLISTMENT_NOT_SUPERIOR</term>
	/// <term>The caller is not a superior transaction manager for the enlistment.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED</term>
	/// <term>The caller did not register to receive TRANSACTION_NOTIFY_COMMIT_COMPLETE notifications.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_TRANSACTION_REQUEST_NOT_VALID</term>
	/// <term>The enlistment's transaction is not in a state that allows it to be committed.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_TRANSACTION_NOT_ACTIVE</term>
	/// <term>The commit operation for this transaction has already been started.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_TRANSACTION_ALREADY_ABORTED</term>
	/// <term>The transaction cannot be committed because it has been rolled back.</term>
	/// </item>
	/// </list>
	/// <para>The routine might return other NTSTATUS values.</para>
	/// </returns>
	/// <remarks>
	/// <para>Only superior transaction managers can call <c>ZwCommitEnlistment</c>.</para>
	/// <para>Callers of <c>ZwCommitEnlistment</c> must register to receive TRANSACTION_NOTIFY_COMMIT_COMPLETE notifications.</para>
	/// <para>
	/// The <c>ZwCommitEnlistment</c> routine causes KTM to send TRANSACTION_NOTIFY_COMMIT notifications to all resource managers that have
	/// enlisted in the transaction.
	/// </para>
	/// <para>For more information about <c>ZwCommitEnlistment</c>, see Creating a Superior Transaction Manager and Handling Commit Operations.</para>
	/// <para>
	/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
	/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship between
	/// the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
	/// </para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-ntcommitenlistment __kernel_entry NTSYSCALLAPI
	// NTSTATUS NtCommitEnlistment( HANDLE EnlistmentHandle, PLARGE_INTEGER TmVirtualClock );
	[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true)]
	[PInvokeData("wdm.h", MSDNShortId = "9c7f3e24-1d7c-450e-bbef-df0479911bc6")]
	public static extern NTStatus NtCommitEnlistment([In] SafeEnlistmentHandle EnlistmentHandle, [In, Optional] IntPtr TmVirtualClock);

	/// <summary>
	/// <para>The <c>ZwCommitTransaction</c> routine initiates a commit operation for a specified transaction.</para>
	/// </summary>
	/// <param name="TransactionHandle">
	/// <para>
	/// A handle to a transaction object. Your component receives this handle from ZwCreateTransaction or ZwOpenTransaction. The handle must
	/// have TRANSACTION_COMMIT access to the object.
	/// </para>
	/// </param>
	/// <param name="Wait">
	/// <para>
	/// A Boolean value that the caller sets to <c>TRUE</c> for synchronous operation or <c>FALSE</c> for asynchronous operation. If this
	/// parameter is <c>TRUE</c>, the call returns after the commit operation is complete.
	/// </para>
	/// </param>
	/// <returns>
	/// <para>
	/// <c>ZwCommitTransaction</c> returns STATUS_SUCCESS if the operation succeeds. Otherwise, this routine might return one of the
	/// following values:
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>Return code</term>
	/// <term>Description</term>
	/// </listheader>
	/// <item>
	/// <term>STATUS_OBJECT_TYPE_MISMATCH</term>
	/// <term>The handle that was specified for the TransactionHandle parameter is not a handle to a transaction object.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_INVALID_HANDLE</term>
	/// <term>The specified transaction object handle is invalid.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_ACCESS_DENIED</term>
	/// <term>The caller does not have appropriate access to the transaction object.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_TRANSACTION_SUPERIOR_EXISTS</term>
	/// <term>The caller cannot commit the transaction because a superior transaction manager exists.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_TRANSACTION_ALREADY_ABORTED</term>
	/// <term>The transaction cannot be committed because it has been rolled back.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_TRANSACTION_ALREADY_COMMITTED</term>
	/// <term>The transaction is already committed.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_TRANSACTION_REQUEST_NOT_VALID</term>
	/// <term>The commit operation for this transaction has already been started.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_PENDING</term>
	/// <term>Commit notifications have been queued to resource managers, and the caller specified FALSE for the Wait parameter.</term>
	/// </item>
	/// </list>
	/// <para>The routine might return other NTSTATUS values.</para>
	/// </returns>
	/// <remarks>
	/// <para>
	/// For more information about how transaction clients should use the <c>ZwCommitTransaction</c> routine, see Creating a Transactional Client.
	/// </para>
	/// <para>For more information about commit operations, see Handling Commit Operations.</para>
	/// <para>
	/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
	/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship between
	/// the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
	/// </para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-ntcommittransaction __kernel_entry NTSYSCALLAPI
	// NTSTATUS NtCommitTransaction( HANDLE TransactionHandle, BOOLEAN Wait );
	[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true)]
	[PInvokeData("wdm.h", MSDNShortId = "145646f3-ff90-41d6-bf76-947cdf93b489")]
	public static extern NTStatus NtCommitTransaction([In] IntPtr TransactionHandle, [MarshalAs(UnmanagedType.U1)] bool Wait);

	/// <summary>
	/// <para>The <c>ZwCreateEnlistment</c> routine creates a new enlistment object for a transaction.</para>
	/// </summary>
	/// <param name="EnlistmentHandle">
	/// <para>
	/// A pointer to a caller-allocated variable that receives a handle to the new enlistment object if the call to
	/// <c>ZwCreateEnlistment</c> succeeds.
	/// </para>
	/// </param>
	/// <param name="DesiredAccess">
	/// <para>
	/// An ACCESS_MASK value that specifies the caller's requested access to the enlistment object. In addition to the access rights that
	/// are defined for all kinds of objects (see ACCESS_MASK), the caller can specify any of the following access right flags for
	/// enlistment objects:
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>ACCESS_MASK flag</term>
	/// <term>Allows the caller to</term>
	/// </listheader>
	/// <item>
	/// <term>ENLISTMENT_QUERY_INFORMATION</term>
	/// <term>Query information about the enlistment (see ZwQueryInformationEnlistment).</term>
	/// </item>
	/// <item>
	/// <term>ENLISTMENT_SET_INFORMATION</term>
	/// <term>Set information for the enlistment (see ZwSetInformationEnlistment).</term>
	/// </item>
	/// <item>
	/// <term>ENLISTMENT_RECOVER</term>
	/// <term>Recover the enlistment (see ZwRecoverEnlistment).</term>
	/// </item>
	/// <item>
	/// <term>ENLISTMENT_SUBORDINATE_RIGHTS</term>
	/// <term>
	/// Perform operations that a resource manager that is not superior performs (see ZwRollbackEnlistment, ZwPrePrepareComplete,
	/// ZwPrepareComplete, ZwCommitComplete, ZwRollbackComplete, ZwSinglePhaseReject, ZwReadOnlyEnlistment).
	/// </term>
	/// </item>
	/// <item>
	/// <term>ENLISTMENT_SUPERIOR_RIGHTS</term>
	/// <term>Perform operations that a superior transaction manager must perform (see ZwPrepareEnlistment, ZwPrePrepareEnlistment, ZwCommitEnlistment).</term>
	/// </item>
	/// </list>
	/// <para>
	/// Alternatively, you can specify one or more of the following ACCESS_MASK bitmaps. These bitmaps combine the flags from the previous
	/// table with the STANDARD_RIGHTS_XXX flags that are described on the ACCESS_MASK reference page. You can also combine these bitmaps
	/// together with additional flags from the previous table. The following table shows how the bitmaps correspond to specific access rights.
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>Generic access right</term>
	/// <term>Set of specific access rights</term>
	/// </listheader>
	/// <item>
	/// <term>ENLISTMENT_GENERIC_READ</term>
	/// <term>STANDARD_RIGHTS_READ and ENLISTMENT_QUERY_INFORMATION</term>
	/// </item>
	/// <item>
	/// <term>ENLISTMENT_GENERIC_WRITE</term>
	/// <term>
	/// STANDARD_RIGHTS_WRITE, ENLISTMENT_SET_INFORMATION, ENLISTMENT_RECOVER, ENLISTMENT_REFERENCE, ENLISTMENT_SUBORDINATE_RIGHTS, and ENLISTMENT_SUPERIOR_RIGHTS
	/// </term>
	/// </item>
	/// <item>
	/// <term>ENLISTMENT_GENERIC_EXECUTE</term>
	/// <term>STANDARD_RIGHTS_EXECUTE, ENLISTMENT_RECOVER, ENLISTMENT_SUBORDINATE_RIGHTS, and ENLISTMENT_SUPERIOR_RIGHTS</term>
	/// </item>
	/// <item>
	/// <term>ENLISTMENT_ALL_ACCESS</term>
	/// <term>STANDARD_RIGHTS_REQUIRED, ENLISTMENT_GENERIC_READ, ENLISTMENT_GENERIC_WRITE, and ENLISTMENT_GENERIC_EXECUTE</term>
	/// </item>
	/// </list>
	/// </param>
	/// <param name="ResourceManagerHandle">
	/// <para>A handle to the caller's resource manager object that was obtained by a previous call to ZwCreateResourceManager or ZwOpenResourceManager.</para>
	/// </param>
	/// <param name="TransactionHandle">
	/// <para>
	/// A handle to a transaction object that was obtained by a previous call to ZwCreateTransaction or ZwOpenTransaction. KTM adds this
	/// transaction to the list of transactions that the calling resource manager is handling.
	/// </para>
	/// </param>
	/// <param name="ObjectAttributes">
	/// <para>
	/// A pointer to an OBJECT_ATTRIBUTES structure that specifies the object name and other attributes. Use the InitializeObjectAttributes
	/// routine to initialize this structure. If the caller is not running in a system thread context, it must set the OBJ_KERNEL_HANDLE
	/// attribute when it calls <c>InitializeObjectAttributes</c>. This parameter is optional and can be <c>NULL</c>.
	/// </para>
	/// </param>
	/// <param name="CreateOptions">
	/// <para>Enlistment option flags. The following table contains the only available flag.</para>
	/// <list type="table">
	/// <listheader>
	/// <term>CreateOptions flag</term>
	/// <term>Meaning</term>
	/// </listheader>
	/// <item>
	/// <term>ENLISTMENT_SUPERIOR</term>
	/// <term>The caller is enlisting as a superior transaction manager for the specified transaction.</term>
	/// </item>
	/// </list>
	/// <para>This parameter is optional and can be zero.</para>
	/// </param>
	/// <param name="NotificationMask">
	/// <para>
	/// A bitwise OR of TRANSACTION_NOTIFY_XXX values that are defined in Ktmtypes.h. This mask specifies the types of transaction
	/// notifications that KTM sends to the caller.
	/// </para>
	/// </param>
	/// <param name="EnlistmentKey">
	/// <para>
	/// A pointer to caller-defined information that uniquely identifies the enlistment. The resource manager receives this pointer when it
	/// calls ZwGetNotificationResourceManager or when KTM calls the ResourceManagerNotification callback routine. The resource manager can
	/// maintain a reference count for this key by calling TmReferenceEnlistmentKey and TmDereferenceEnlistmentKey. This parameter is
	/// optional and can be <c>NULL</c>.
	/// </para>
	/// </param>
	/// <returns>
	/// <para>
	/// <c>ZwCreateEnlistment</c> returns STATUS_SUCCESS if the operation succeeds. Otherwise, this routine might return one of the
	/// following values:
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>Return code</term>
	/// <term>Description</term>
	/// </listheader>
	/// <item>
	/// <term>STATUS_INVALID_HANDLE</term>
	/// <term>An object handle is invalid.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_INVALID_PARAMETER</term>
	/// <term>
	/// The CreateOptions or NotificationMask parameter's value is invalid, or KTM could not find the transaction that the TransactionHandle
	/// parameter specifies.
	/// </term>
	/// </item>
	/// <item>
	/// <term>STATUS_INSUFFICIENT_RESOURCES</term>
	/// <term>A memory allocation failed.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_TRANSACTIONMANAGER_NOT_ONLINE</term>
	/// <term>The enlistment failed because KTM or the resource manager is not in an operational state.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_TRANSACTION_NOT_ACTIVE</term>
	/// <term>The enlistment failed because the transaction that the TransactionHandle parameter specifies is not active.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_TRANSACTION_SUPERIOR_EXISTS</term>
	/// <term>The caller tried to register as a superior transaction manager but a superior transaction manager already exists.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_TM_VOLATILE</term>
	/// <term>
	/// The caller is trying to register as a superior transaction manager, but the caller's resource manager object is volatile while the
	/// associated transaction manager object is not volatile.
	/// </term>
	/// </item>
	/// <item>
	/// <term>STATUS_ACCESS_DENIED</term>
	/// <term>The value of the DesiredAccess parameter is invalid.</term>
	/// </item>
	/// </list>
	/// <para>The routine might return other NTSTATUS values.</para>
	/// </returns>
	/// <remarks>
	/// <para>A resource manager calls <c>ZwCreateEnlistment</c> to enlist in a transaction.</para>
	/// <para>Resource managers that are not superior must include the ENLISTMENT_SUBORDINATE_RIGHTS flag in their access mask.</para>
	/// <para>
	/// Superior transaction managers must include the ENLISTMENT_SUPERIOR_RIGHTS flag in their access masks. Typically, a superior
	/// transaction manager includes code that calls ZwRollbackEnlistment, so it must also include the ENLISTMENT_SUBORDINATE_RIGHTS flag.
	/// </para>
	/// <para>A resource manager that calls <c>ZwCreateEnlistment</c> must eventually call ZwClose to close the object handle.</para>
	/// <para>
	/// Your resource manager can use the EnlistmentKey parameter to assign a unique value to each enlistment, such as a pointer to a data
	/// structure that contains information about the enlistment. For example, if the resource manager stores the enlistment object's handle
	/// in the structure, the resource manager can do the following:
	/// </para>
	/// <para>
	/// For more information about <c>ZwCreateEnlistment</c>, see Creating a Resource Manager and Creating a Superior Transaction Manager.
	/// </para>
	/// <para>
	/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
	/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship between
	/// the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
	/// </para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-ntcreateenlistment __kernel_entry NTSYSCALLAPI
	// NTSTATUS NtCreateEnlistment( PHANDLE EnlistmentHandle, ACCESS_MASK DesiredAccess, HANDLE ResourceManagerHandle, HANDLE
	// TransactionHandle, POBJECT_ATTRIBUTES ObjectAttributes, ULONG CreateOptions, NOTIFICATION_MASK NotificationMask, PVOID EnlistmentKey );
	[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true)]
	[PInvokeData("wdm.h", MSDNShortId = "5ffd8262-10b3-4c40-bd3e-050271338508")]
	public static extern NTStatus NtCreateEnlistment(out SafeEnlistmentHandle EnlistmentHandle, ACCESS_MASK DesiredAccess, [In] SafeResourceManagerHandle ResourceManagerHandle,
		[In] SafeTransactionHandle TransactionHandle, in OBJECT_ATTRIBUTES ObjectAttributes, [Optional] uint CreateOptions, [In, Optional] NOTIFICATION_MASK NotificationMask, [In, Optional] IntPtr EnlistmentKey);

	/// <summary>
	/// <para>The <c>ZwCreateEnlistment</c> routine creates a new enlistment object for a transaction.</para>
	/// </summary>
	/// <param name="EnlistmentHandle">
	/// <para>
	/// A pointer to a caller-allocated variable that receives a handle to the new enlistment object if the call to
	/// <c>ZwCreateEnlistment</c> succeeds.
	/// </para>
	/// </param>
	/// <param name="DesiredAccess">
	/// <para>
	/// An ACCESS_MASK value that specifies the caller's requested access to the enlistment object. In addition to the access rights that
	/// are defined for all kinds of objects (see ACCESS_MASK), the caller can specify any of the following access right flags for
	/// enlistment objects:
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>ACCESS_MASK flag</term>
	/// <term>Allows the caller to</term>
	/// </listheader>
	/// <item>
	/// <term>ENLISTMENT_QUERY_INFORMATION</term>
	/// <term>Query information about the enlistment (see ZwQueryInformationEnlistment).</term>
	/// </item>
	/// <item>
	/// <term>ENLISTMENT_SET_INFORMATION</term>
	/// <term>Set information for the enlistment (see ZwSetInformationEnlistment).</term>
	/// </item>
	/// <item>
	/// <term>ENLISTMENT_RECOVER</term>
	/// <term>Recover the enlistment (see ZwRecoverEnlistment).</term>
	/// </item>
	/// <item>
	/// <term>ENLISTMENT_SUBORDINATE_RIGHTS</term>
	/// <term>
	/// Perform operations that a resource manager that is not superior performs (see ZwRollbackEnlistment, ZwPrePrepareComplete,
	/// ZwPrepareComplete, ZwCommitComplete, ZwRollbackComplete, ZwSinglePhaseReject, ZwReadOnlyEnlistment).
	/// </term>
	/// </item>
	/// <item>
	/// <term>ENLISTMENT_SUPERIOR_RIGHTS</term>
	/// <term>Perform operations that a superior transaction manager must perform (see ZwPrepareEnlistment, ZwPrePrepareEnlistment, ZwCommitEnlistment).</term>
	/// </item>
	/// </list>
	/// <para>
	/// Alternatively, you can specify one or more of the following ACCESS_MASK bitmaps. These bitmaps combine the flags from the previous
	/// table with the STANDARD_RIGHTS_XXX flags that are described on the ACCESS_MASK reference page. You can also combine these bitmaps
	/// together with additional flags from the previous table. The following table shows how the bitmaps correspond to specific access rights.
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>Generic access right</term>
	/// <term>Set of specific access rights</term>
	/// </listheader>
	/// <item>
	/// <term>ENLISTMENT_GENERIC_READ</term>
	/// <term>STANDARD_RIGHTS_READ and ENLISTMENT_QUERY_INFORMATION</term>
	/// </item>
	/// <item>
	/// <term>ENLISTMENT_GENERIC_WRITE</term>
	/// <term>
	/// STANDARD_RIGHTS_WRITE, ENLISTMENT_SET_INFORMATION, ENLISTMENT_RECOVER, ENLISTMENT_REFERENCE, ENLISTMENT_SUBORDINATE_RIGHTS, and ENLISTMENT_SUPERIOR_RIGHTS
	/// </term>
	/// </item>
	/// <item>
	/// <term>ENLISTMENT_GENERIC_EXECUTE</term>
	/// <term>STANDARD_RIGHTS_EXECUTE, ENLISTMENT_RECOVER, ENLISTMENT_SUBORDINATE_RIGHTS, and ENLISTMENT_SUPERIOR_RIGHTS</term>
	/// </item>
	/// <item>
	/// <term>ENLISTMENT_ALL_ACCESS</term>
	/// <term>STANDARD_RIGHTS_REQUIRED, ENLISTMENT_GENERIC_READ, ENLISTMENT_GENERIC_WRITE, and ENLISTMENT_GENERIC_EXECUTE</term>
	/// </item>
	/// </list>
	/// </param>
	/// <param name="ResourceManagerHandle">
	/// <para>A handle to the caller's resource manager object that was obtained by a previous call to ZwCreateResourceManager or ZwOpenResourceManager.</para>
	/// </param>
	/// <param name="TransactionHandle">
	/// <para>
	/// A handle to a transaction object that was obtained by a previous call to ZwCreateTransaction or ZwOpenTransaction. KTM adds this
	/// transaction to the list of transactions that the calling resource manager is handling.
	/// </para>
	/// </param>
	/// <param name="ObjectAttributes">
	/// <para>
	/// A pointer to an OBJECT_ATTRIBUTES structure that specifies the object name and other attributes. Use the InitializeObjectAttributes
	/// routine to initialize this structure. If the caller is not running in a system thread context, it must set the OBJ_KERNEL_HANDLE
	/// attribute when it calls <c>InitializeObjectAttributes</c>. This parameter is optional and can be <c>NULL</c>.
	/// </para>
	/// </param>
	/// <param name="CreateOptions">
	/// <para>Enlistment option flags. The following table contains the only available flag.</para>
	/// <list type="table">
	/// <listheader>
	/// <term>CreateOptions flag</term>
	/// <term>Meaning</term>
	/// </listheader>
	/// <item>
	/// <term>ENLISTMENT_SUPERIOR</term>
	/// <term>The caller is enlisting as a superior transaction manager for the specified transaction.</term>
	/// </item>
	/// </list>
	/// <para>This parameter is optional and can be zero.</para>
	/// </param>
	/// <param name="NotificationMask">
	/// <para>
	/// A bitwise OR of TRANSACTION_NOTIFY_XXX values that are defined in Ktmtypes.h. This mask specifies the types of transaction
	/// notifications that KTM sends to the caller.
	/// </para>
	/// </param>
	/// <param name="EnlistmentKey">
	/// <para>
	/// A pointer to caller-defined information that uniquely identifies the enlistment. The resource manager receives this pointer when it
	/// calls ZwGetNotificationResourceManager or when KTM calls the ResourceManagerNotification callback routine. The resource manager can
	/// maintain a reference count for this key by calling TmReferenceEnlistmentKey and TmDereferenceEnlistmentKey. This parameter is
	/// optional and can be <c>NULL</c>.
	/// </para>
	/// </param>
	/// <returns>
	/// <para>
	/// <c>ZwCreateEnlistment</c> returns STATUS_SUCCESS if the operation succeeds. Otherwise, this routine might return one of the
	/// following values:
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>Return code</term>
	/// <term>Description</term>
	/// </listheader>
	/// <item>
	/// <term>STATUS_INVALID_HANDLE</term>
	/// <term>An object handle is invalid.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_INVALID_PARAMETER</term>
	/// <term>
	/// The CreateOptions or NotificationMask parameter's value is invalid, or KTM could not find the transaction that the TransactionHandle
	/// parameter specifies.
	/// </term>
	/// </item>
	/// <item>
	/// <term>STATUS_INSUFFICIENT_RESOURCES</term>
	/// <term>A memory allocation failed.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_TRANSACTIONMANAGER_NOT_ONLINE</term>
	/// <term>The enlistment failed because KTM or the resource manager is not in an operational state.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_TRANSACTION_NOT_ACTIVE</term>
	/// <term>The enlistment failed because the transaction that the TransactionHandle parameter specifies is not active.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_TRANSACTION_SUPERIOR_EXISTS</term>
	/// <term>The caller tried to register as a superior transaction manager but a superior transaction manager already exists.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_TM_VOLATILE</term>
	/// <term>
	/// The caller is trying to register as a superior transaction manager, but the caller's resource manager object is volatile while the
	/// associated transaction manager object is not volatile.
	/// </term>
	/// </item>
	/// <item>
	/// <term>STATUS_ACCESS_DENIED</term>
	/// <term>The value of the DesiredAccess parameter is invalid.</term>
	/// </item>
	/// </list>
	/// <para>The routine might return other NTSTATUS values.</para>
	/// </returns>
	/// <remarks>
	/// <para>A resource manager calls <c>ZwCreateEnlistment</c> to enlist in a transaction.</para>
	/// <para>Resource managers that are not superior must include the ENLISTMENT_SUBORDINATE_RIGHTS flag in their access mask.</para>
	/// <para>
	/// Superior transaction managers must include the ENLISTMENT_SUPERIOR_RIGHTS flag in their access masks. Typically, a superior
	/// transaction manager includes code that calls ZwRollbackEnlistment, so it must also include the ENLISTMENT_SUBORDINATE_RIGHTS flag.
	/// </para>
	/// <para>A resource manager that calls <c>ZwCreateEnlistment</c> must eventually call ZwClose to close the object handle.</para>
	/// <para>
	/// Your resource manager can use the EnlistmentKey parameter to assign a unique value to each enlistment, such as a pointer to a data
	/// structure that contains information about the enlistment. For example, if the resource manager stores the enlistment object's handle
	/// in the structure, the resource manager can do the following:
	/// </para>
	/// <para>
	/// For more information about <c>ZwCreateEnlistment</c>, see Creating a Resource Manager and Creating a Superior Transaction Manager.
	/// </para>
	/// <para>
	/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
	/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship between
	/// the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
	/// </para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-ntcreateenlistment __kernel_entry NTSYSCALLAPI
	// NTSTATUS NtCreateEnlistment( PHANDLE EnlistmentHandle, ACCESS_MASK DesiredAccess, HANDLE ResourceManagerHandle, HANDLE
	// TransactionHandle, POBJECT_ATTRIBUTES ObjectAttributes, ULONG CreateOptions, NOTIFICATION_MASK NotificationMask, PVOID EnlistmentKey );
	[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true)]
	[PInvokeData("wdm.h", MSDNShortId = "5ffd8262-10b3-4c40-bd3e-050271338508")]
	public static extern NTStatus NtCreateEnlistment(out SafeEnlistmentHandle EnlistmentHandle, ACCESS_MASK DesiredAccess, [In] SafeResourceManagerHandle ResourceManagerHandle,
		[In] SafeTransactionHandle TransactionHandle, [In, Optional] IntPtr ObjectAttributes, [Optional] uint CreateOptions, [In, Optional] NOTIFICATION_MASK NotificationMask, [In, Optional] IntPtr EnlistmentKey);

	/// <summary>
	/// <para>The <c>ZwCreateResourceManager</c> routine creates a resource manager object.</para>
	/// </summary>
	/// <param name="ResourceManagerHandle">
	/// <para>
	/// A pointer to a caller-allocated variable that receives a handle to the new resource manager object if the call to
	/// <c>ZwCreateResourceManager</c> is successful.
	/// </para>
	/// </param>
	/// <param name="DesiredAccess">
	/// <para>
	/// An ACCESS_MASK value that specifies the caller's requested access to the resource manager object. In addition to the access rights
	/// that are defined for all kinds of objects (see <c>ACCESS_MASK</c>), the caller can specify any of the following access right flags
	/// for resource manager objects:
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>ACCESS_MASK flag</term>
	/// <term>Allows the caller to</term>
	/// </listheader>
	/// <item>
	/// <term>RESOURCEMANAGER_ENLIST</term>
	/// <term>Enlist in transactions (see ZwCreateEnlistment).</term>
	/// </item>
	/// <item>
	/// <term>RESOURCEMANAGER_GET_NOTIFICATION</term>
	/// <term>Receive notifications about the transactions that are associated with this resource manager (see ZwGetNotificationResourceManager).</term>
	/// </item>
	/// <item>
	/// <term>RESOURCEMANAGER_REGISTER_PROTOCOL</term>
	/// <term>Not used.</term>
	/// </item>
	/// <item>
	/// <term>RESOURCEMANAGER_QUERY_INFORMATION</term>
	/// <term>Query information about the resource manager (see ZwQueryInformationResourceManager).</term>
	/// </item>
	/// <item>
	/// <term>RESOURCEMANAGER_SET_INFORMATION</term>
	/// <term>Not used.</term>
	/// </item>
	/// <item>
	/// <term>RESOURCEMANAGER_RECOVER</term>
	/// <term>Recover the resource manager (see ZwRecoverResourceManager).</term>
	/// </item>
	/// <item>
	/// <term>RESOURCEMANAGER_COMPLETE_PROPAGATION</term>
	/// <term>Not used.</term>
	/// </item>
	/// </list>
	/// <para>
	/// Alternatively, you can specify one or more of the following generic ACCESS_MASK flags. (The STANDARD_RIGHTS_Xxx flags are predefined
	/// system values that are used to enforce security on system objects.) You can also combine these generic flags with additional flags
	/// from the preceding table. The following table shows how generic access rights correspond to specific access rights.
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>Generic access right</term>
	/// <term>Set of specific access rights</term>
	/// </listheader>
	/// <item>
	/// <term>RESOURCEMANAGER_GENERIC_READ</term>
	/// <term>STANDARD_RIGHTS_READ, RESOURCEMANAGER_QUERY_INFORMATION, and SYNCHRONIZE</term>
	/// </item>
	/// <item>
	/// <term>RESOURCEMANAGER_GENERIC_WRITE</term>
	/// <term>
	/// STANDARD_RIGHTS_WRITE, RESOURCEMANAGER_SET_INFORMATION, RESOURCEMANAGER_RECOVER, RESOURCEMANAGER_ENLIST,
	/// RESOURCEMANAGER_GET_NOTIFICATION, RESOURCEMANAGER_REGISTER_PROTOCOL, RESOURCEMANAGER_COMPLETE_PROPAGATION, and SYNCHRONIZE
	/// </term>
	/// </item>
	/// <item>
	/// <term>RESOURCEMANAGER_GENERIC_EXECUTE</term>
	/// <term>
	/// STANDARD_RIGHTS_EXECUTE, RESOURCEMANAGER_RECOVER, RESOURCEMANAGER_ENLIST, RESOURCEMANAGER_GET_NOTIFICATION,
	/// RESOURCEMANAGER_COMPLETE_PROPAGATION, and SYNCHRONIZE
	/// </term>
	/// </item>
	/// <item>
	/// <term>RESOURCEMANAGER_ALL_ACCESS</term>
	/// <term>STANDARD_RIGHTS_REQUIRED, RESOURCEMANAGER_GENERIC_READ, RESOURCEMANAGER_GENERIC_WRITE, and RESOURCEMANAGER_GENERIC_EXECUTE</term>
	/// </item>
	/// </list>
	/// </param>
	/// <param name="TmHandle">
	/// <para>A handle to a transaction manager object that was obtained by a previous all to ZwCreateTransactionManager or ZwOpenTransactionManager.</para>
	/// </param>
	/// <param name="RmGuid">
	/// <para>A pointer to a GUID that KTM will use to identify the resource manager. If this pointer is <c>NULL</c>, KTM generates a GUID.</para>
	/// </param>
	/// <param name="ObjectAttributes">
	/// <para>
	/// A pointer to an OBJECT_ATTRIBUTES structure that specifies the object name and other attributes. Use the InitializeObjectAttributes
	/// routine to initialize this structure. If the caller is not running in a system thread context, it must set the OBJ_KERNEL_HANDLE
	/// attribute when it calls <c>InitializeObjectAttributes</c>. This parameter is optional and can be <c>NULL</c>.
	/// </para>
	/// </param>
	/// <param name="CreateOptions">
	/// <para>Optional object creation flags. The following table contains the available flags, which are defined in Ktmtypes.h.</para>
	/// <list type="table">
	/// <listheader>
	/// <term>CreateOptions flag</term>
	/// <term>Meaning</term>
	/// </listheader>
	/// <item>
	/// <term>RESOURCE_MANAGER_COMMUNICATION</term>
	/// <term>For internal use only.</term>
	/// </item>
	/// <item>
	/// <term>RESOURCE_MANAGER_VOLATILE</term>
	/// <term>The caller will manage volatile resources. It will be non-persistent and will not perform recovery.</term>
	/// </item>
	/// </list>
	/// <para>This parameter is optional and can be zero.</para>
	/// </param>
	/// <param name="Description">
	/// <para>
	/// A pointer to a caller-supplied UNICODE_STRING structure that contains a NULL-terminated string. The string provides a description of
	/// the resource manager. KTM stores a copy of the string and includes the string in messages that it writes to the log stream. The
	/// maximum string length is MAX_RESOURCEMANAGER_DESCRIPTION_LENGTH. This parameter is optional and can be <c>NULL</c>.
	/// </para>
	/// </param>
	/// <returns>
	/// <para>
	/// <c>ZwCreateResourceManager</c> returns STATUS_SUCCESS if the operation succeeds. Otherwise, this routine might return one of the
	/// following values:
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>Return code</term>
	/// <term>Description</term>
	/// </listheader>
	/// <item>
	/// <term>STATUS_OBJECT_TYPE_MISMATCH</term>
	/// <term>The handle that TmHandle specifies is not a handle to a transaction object.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_INVALID_HANDLE</term>
	/// <term>The handle that TmHandle specifies is invalid.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_ACCESS_DENIED</term>
	/// <term>The caller does not have appropriate access to the specified transaction manager object.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_TRANSACTION_OBJECT_EXPIRED</term>
	/// <term>The handle that TmHandle specifies is closed.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_INVALID_PARAMETER</term>
	/// <term>The CreateOptions parameter's value is invalid or the Description parameter's string is too long.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_TM_VOLATILE</term>
	/// <term>
	/// The CreateOptions parameter does not specify RESOURCE_MANAGER_VOLATILE but the transaction manager that TmHandle specifies is volatile.
	/// </term>
	/// </item>
	/// <item>
	/// <term>STATUS_OBJECT_NAME_COLLISION</term>
	/// <term>The GUID that ResourceManagerGuid specifies already exists.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_ACCESS_DENIED</term>
	/// <term>The value of the DesiredAccess parameter is invalid.</term>
	/// </item>
	/// </list>
	/// <para>The routine might return other NTSTATUS values.</para>
	/// </returns>
	/// <remarks>
	/// <para>A resource manager that calls <c>ZwCreateResourceManager</c> must eventually call ZwClose to close the object handle.</para>
	/// <para>For more information about <c>ZwCreateResourceManager</c>, see Creating a Resource Manager.</para>
	/// <para>
	/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
	/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship between
	/// the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
	/// </para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-ntcreateresourcemanager __kernel_entry NTSYSCALLAPI
	// NTSTATUS NtCreateResourceManager( PHANDLE ResourceManagerHandle, ACCESS_MASK DesiredAccess, HANDLE TmHandle, LPGUID RmGuid,
	// POBJECT_ATTRIBUTES ObjectAttributes, ULONG CreateOptions, PUNICODE_STRING Description );
	[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true)]
	[PInvokeData("wdm.h", MSDNShortId = "4812eeb4-134f-4ecb-870b-dbab04c1137b")]
	public static extern NTStatus NtCreateResourceManager(out SafeResourceManagerHandle ResourceManagerHandle, ACCESS_MASK DesiredAccess, SafeTransactionManagerHandle TmHandle, in Guid RmGuid,
		in OBJECT_ATTRIBUTES ObjectAttributes, [Optional] uint CreateOptions, [In, Optional, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UnicodeStringMarshaler))] string? Description);

	/// <summary>
	/// <para>The <c>ZwCreateResourceManager</c> routine creates a resource manager object.</para>
	/// </summary>
	/// <param name="ResourceManagerHandle">
	/// <para>
	/// A pointer to a caller-allocated variable that receives a handle to the new resource manager object if the call to
	/// <c>ZwCreateResourceManager</c> is successful.
	/// </para>
	/// </param>
	/// <param name="DesiredAccess">
	/// <para>
	/// An ACCESS_MASK value that specifies the caller's requested access to the resource manager object. In addition to the access rights
	/// that are defined for all kinds of objects (see <c>ACCESS_MASK</c>), the caller can specify any of the following access right flags
	/// for resource manager objects:
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>ACCESS_MASK flag</term>
	/// <term>Allows the caller to</term>
	/// </listheader>
	/// <item>
	/// <term>RESOURCEMANAGER_ENLIST</term>
	/// <term>Enlist in transactions (see ZwCreateEnlistment).</term>
	/// </item>
	/// <item>
	/// <term>RESOURCEMANAGER_GET_NOTIFICATION</term>
	/// <term>Receive notifications about the transactions that are associated with this resource manager (see ZwGetNotificationResourceManager).</term>
	/// </item>
	/// <item>
	/// <term>RESOURCEMANAGER_REGISTER_PROTOCOL</term>
	/// <term>Not used.</term>
	/// </item>
	/// <item>
	/// <term>RESOURCEMANAGER_QUERY_INFORMATION</term>
	/// <term>Query information about the resource manager (see ZwQueryInformationResourceManager).</term>
	/// </item>
	/// <item>
	/// <term>RESOURCEMANAGER_SET_INFORMATION</term>
	/// <term>Not used.</term>
	/// </item>
	/// <item>
	/// <term>RESOURCEMANAGER_RECOVER</term>
	/// <term>Recover the resource manager (see ZwRecoverResourceManager).</term>
	/// </item>
	/// <item>
	/// <term>RESOURCEMANAGER_COMPLETE_PROPAGATION</term>
	/// <term>Not used.</term>
	/// </item>
	/// </list>
	/// <para>
	/// Alternatively, you can specify one or more of the following generic ACCESS_MASK flags. (The STANDARD_RIGHTS_Xxx flags are predefined
	/// system values that are used to enforce security on system objects.) You can also combine these generic flags with additional flags
	/// from the preceding table. The following table shows how generic access rights correspond to specific access rights.
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>Generic access right</term>
	/// <term>Set of specific access rights</term>
	/// </listheader>
	/// <item>
	/// <term>RESOURCEMANAGER_GENERIC_READ</term>
	/// <term>STANDARD_RIGHTS_READ, RESOURCEMANAGER_QUERY_INFORMATION, and SYNCHRONIZE</term>
	/// </item>
	/// <item>
	/// <term>RESOURCEMANAGER_GENERIC_WRITE</term>
	/// <term>
	/// STANDARD_RIGHTS_WRITE, RESOURCEMANAGER_SET_INFORMATION, RESOURCEMANAGER_RECOVER, RESOURCEMANAGER_ENLIST,
	/// RESOURCEMANAGER_GET_NOTIFICATION, RESOURCEMANAGER_REGISTER_PROTOCOL, RESOURCEMANAGER_COMPLETE_PROPAGATION, and SYNCHRONIZE
	/// </term>
	/// </item>
	/// <item>
	/// <term>RESOURCEMANAGER_GENERIC_EXECUTE</term>
	/// <term>
	/// STANDARD_RIGHTS_EXECUTE, RESOURCEMANAGER_RECOVER, RESOURCEMANAGER_ENLIST, RESOURCEMANAGER_GET_NOTIFICATION,
	/// RESOURCEMANAGER_COMPLETE_PROPAGATION, and SYNCHRONIZE
	/// </term>
	/// </item>
	/// <item>
	/// <term>RESOURCEMANAGER_ALL_ACCESS</term>
	/// <term>STANDARD_RIGHTS_REQUIRED, RESOURCEMANAGER_GENERIC_READ, RESOURCEMANAGER_GENERIC_WRITE, and RESOURCEMANAGER_GENERIC_EXECUTE</term>
	/// </item>
	/// </list>
	/// </param>
	/// <param name="TmHandle">
	/// <para>A handle to a transaction manager object that was obtained by a previous all to ZwCreateTransactionManager or ZwOpenTransactionManager.</para>
	/// </param>
	/// <param name="RmGuid">
	/// <para>A pointer to a GUID that KTM will use to identify the resource manager. If this pointer is <c>NULL</c>, KTM generates a GUID.</para>
	/// </param>
	/// <param name="ObjectAttributes">
	/// <para>
	/// A pointer to an OBJECT_ATTRIBUTES structure that specifies the object name and other attributes. Use the InitializeObjectAttributes
	/// routine to initialize this structure. If the caller is not running in a system thread context, it must set the OBJ_KERNEL_HANDLE
	/// attribute when it calls <c>InitializeObjectAttributes</c>. This parameter is optional and can be <c>NULL</c>.
	/// </para>
	/// </param>
	/// <param name="CreateOptions">
	/// <para>Optional object creation flags. The following table contains the available flags, which are defined in Ktmtypes.h.</para>
	/// <list type="table">
	/// <listheader>
	/// <term>CreateOptions flag</term>
	/// <term>Meaning</term>
	/// </listheader>
	/// <item>
	/// <term>RESOURCE_MANAGER_COMMUNICATION</term>
	/// <term>For internal use only.</term>
	/// </item>
	/// <item>
	/// <term>RESOURCE_MANAGER_VOLATILE</term>
	/// <term>The caller will manage volatile resources. It will be non-persistent and will not perform recovery.</term>
	/// </item>
	/// </list>
	/// <para>This parameter is optional and can be zero.</para>
	/// </param>
	/// <param name="Description">
	/// <para>
	/// A pointer to a caller-supplied UNICODE_STRING structure that contains a NULL-terminated string. The string provides a description of
	/// the resource manager. KTM stores a copy of the string and includes the string in messages that it writes to the log stream. The
	/// maximum string length is MAX_RESOURCEMANAGER_DESCRIPTION_LENGTH. This parameter is optional and can be <c>NULL</c>.
	/// </para>
	/// </param>
	/// <returns>
	/// <para>
	/// <c>ZwCreateResourceManager</c> returns STATUS_SUCCESS if the operation succeeds. Otherwise, this routine might return one of the
	/// following values:
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>Return code</term>
	/// <term>Description</term>
	/// </listheader>
	/// <item>
	/// <term>STATUS_OBJECT_TYPE_MISMATCH</term>
	/// <term>The handle that TmHandle specifies is not a handle to a transaction object.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_INVALID_HANDLE</term>
	/// <term>The handle that TmHandle specifies is invalid.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_ACCESS_DENIED</term>
	/// <term>The caller does not have appropriate access to the specified transaction manager object.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_TRANSACTION_OBJECT_EXPIRED</term>
	/// <term>The handle that TmHandle specifies is closed.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_INVALID_PARAMETER</term>
	/// <term>The CreateOptions parameter's value is invalid or the Description parameter's string is too long.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_TM_VOLATILE</term>
	/// <term>
	/// The CreateOptions parameter does not specify RESOURCE_MANAGER_VOLATILE but the transaction manager that TmHandle specifies is volatile.
	/// </term>
	/// </item>
	/// <item>
	/// <term>STATUS_OBJECT_NAME_COLLISION</term>
	/// <term>The GUID that ResourceManagerGuid specifies already exists.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_ACCESS_DENIED</term>
	/// <term>The value of the DesiredAccess parameter is invalid.</term>
	/// </item>
	/// </list>
	/// <para>The routine might return other NTSTATUS values.</para>
	/// </returns>
	/// <remarks>
	/// <para>A resource manager that calls <c>ZwCreateResourceManager</c> must eventually call ZwClose to close the object handle.</para>
	/// <para>For more information about <c>ZwCreateResourceManager</c>, see Creating a Resource Manager.</para>
	/// <para>
	/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
	/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship between
	/// the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
	/// </para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-ntcreateresourcemanager __kernel_entry NTSYSCALLAPI
	// NTSTATUS NtCreateResourceManager( PHANDLE ResourceManagerHandle, ACCESS_MASK DesiredAccess, HANDLE TmHandle, LPGUID RmGuid,
	// POBJECT_ATTRIBUTES ObjectAttributes, ULONG CreateOptions, PUNICODE_STRING Description );
	[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true)]
	[PInvokeData("wdm.h", MSDNShortId = "4812eeb4-134f-4ecb-870b-dbab04c1137b")]
	public static extern NTStatus NtCreateResourceManager(out SafeResourceManagerHandle ResourceManagerHandle, ACCESS_MASK DesiredAccess, SafeTransactionManagerHandle TmHandle, [In, Optional] IntPtr RmGuid,
		[In, Optional] IntPtr ObjectAttributes, [Optional] uint CreateOptions, [In, Optional, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UnicodeStringMarshaler))] string? Description);

	/// <summary>
	/// <para>The <c>ZwCreateTransaction</c> routine creates a transaction object.</para>
	/// </summary>
	/// <param name="TransactionHandle">
	/// <para>
	/// A pointer to a caller-allocated variable that receives a handle to the new transaction object, if the call to
	/// <c>ZwCreateTransaction</c> succeeds.
	/// </para>
	/// </param>
	/// <param name="DesiredAccess">
	/// <para>
	/// An ACCESS_MASK value that specifies the caller's requested access to the transaction object. In addition to the access rights that
	/// are defined for all kinds of objects (see ACCESS_MASK), the caller can specify any of the following flags for transaction objects.
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>Access mask</term>
	/// <term>Allows the caller to</term>
	/// </listheader>
	/// <item>
	/// <term>TRANSACTION_COMMIT</term>
	/// <term>Commit the transaction (see ZwCommitTransaction).</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_ENLIST</term>
	/// <term>Create an enlistment for the transaction (see ZwCreateEnlistment).</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_PROPAGATE</term>
	/// <term>Do not use.</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_QUERY_INFORMATION</term>
	/// <term>Obtain information about the transaction (see ZwQueryInformationTransaction).</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_ROLLBACK</term>
	/// <term>Roll back the transaction (see ZwRollbackTransaction).</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_SET_INFORMATION</term>
	/// <term>Set information for the transaction (see ZwSetInformationTransaction).</term>
	/// </item>
	/// </list>
	/// <para>
	/// Alternatively, you can specify one or more of the following ACCESS_MASK bitmaps. These bitmaps combine the flags from the previous
	/// table with the STANDARD_RIGHTS_XXX flags that are described on the ACCESS_MASK reference page. You can also combine these bitmaps
	/// with additional flags from the preceding table. The following table shows how the bitmaps correspond to specific access rights.
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>Rights bitmap</term>
	/// <term>Set of specific access rights</term>
	/// </listheader>
	/// <item>
	/// <term>TRANSACTION_GENERIC_READ</term>
	/// <term>STANDARD_RIGHTS_READ, TRANSACTION_QUERY_INFORMATION, and SYNCHRONIZE</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_GENERIC_WRITE</term>
	/// <term>
	/// STANDARD_RIGHTS_WRITE, TRANSACTION_SET_INFORMATION, TRANSACTION_COMMIT, TRANSACTION_ENLIST, TRANSACTION_ROLLBACK,
	/// TRANSACTION_PROPAGATE, TRANSACTION_SAVEPOINT, and SYNCHRONIZE
	/// </term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_GENERIC_EXECUTE</term>
	/// <term>STANDARD_RIGHTS_EXECUTE, TRANSACTION_COMMIT, TRANSACTION_ROLLBACK, and SYNCHRONIZE</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_ALL_ACCESS</term>
	/// <term>STANDARD_RIGHTS_REQUIRED, TRANSACTION_GENERIC_READ, TRANSACTION_GENERIC_WRITE, and TRANSACTION_GENERIC_EXECUTE</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_RESOURCE_MANAGER_RIGHTS</term>
	/// <term>
	/// STANDARD_RIGHTS_WRITE, TRANSACTION_GENERIC_READ, TRANSACTION_SET_INFORMATION, TRANSACTION_ENLIST, TRANSACTION_ROLLBACK,
	/// TRANSACTION_PROPAGATE, and SYNCHRONIZE
	/// </term>
	/// </item>
	/// </list>
	/// <para>Typically, a resource manager specifies TRANSACTION_RESOURCE_MANAGER_RIGHTS.</para>
	/// <para>The DesiredAccess value cannot be zero.</para>
	/// </param>
	/// <param name="ObjectAttributes">
	/// <para>
	/// A pointer to an OBJECT_ATTRIBUTES structure that specifies the object name and other attributes. Use the InitializeObjectAttributes
	/// routine to initialize this structure. If the caller is not running in a system thread context, it must set the OBJ_KERNEL_HANDLE
	/// attribute when it calls <c>InitializeObjectAttributes</c>. This parameter is optional and can be <c>NULL</c>.
	/// </para>
	/// </param>
	/// <param name="Uow">
	/// <para>
	/// A pointer to a GUID that KTM uses as the new transaction object's unit of work (UOW) identifier. This parameter is optional and can
	/// be <c>NULL</c>. If this parameter is <c>NULL</c>, KTM generates a GUID and assigns it to the transaction object. For more
	/// information, see the following Remarks section.
	/// </para>
	/// </param>
	/// <param name="TmHandle">
	/// <para>
	/// A handle to a transaction manager object that was obtained by a previous call to ZwCreateTransactionManager or
	/// ZwOpenTransactionManager. KTM assigns the new transaction object to the specified transaction manager object. If this parameter is
	/// <c>NULL</c>, KTM assigns the new transaction object to a transaction manager later, when a resource manager creates an enlistment
	/// for the transaction.
	/// </para>
	/// </param>
	/// <param name="CreateOptions">
	/// <para>Optional object creation flags. The following table contains the available flags, which are defined in Ktmtypes.h.</para>
	/// <list type="table">
	/// <listheader>
	/// <term>Option flag</term>
	/// <term>Meaning</term>
	/// </listheader>
	/// <item>
	/// <term>TRANSACTION_DO_NOT_PROMOTE</term>
	/// <term>Reserved for future use.</term>
	/// </item>
	/// </list>
	/// </param>
	/// <param name="IsolationLevel">
	/// <para>Reserved for future use. Callers must set this parameter to zero.</para>
	/// </param>
	/// <param name="IsolationFlags">
	/// <para>Reserved for future use. Callers should set this parameter to zero.</para>
	/// </param>
	/// <param name="Timeout">
	/// <para>
	/// A pointer to a time-out value. If the transaction has not been committed by the time specified by this parameter, KTM rolls back the
	/// transaction. The time-out value is expressed in system time units (100-nanosecond intervals), and can specify either an absolute
	/// time or a relative time. If the value pointed to by Timeout is negative, the expiration time is relative to the current system time.
	/// Otherwise, the expiration time is absolute. This pointer is optional and can be <c>NULL</c> if you do not want the transaction to
	/// have a time-out value. If Timeout = <c>NULL</c> or *Timeout = 0, the transaction never times out. (You can also use
	/// ZwSetInformationTransaction to set a time-out value.)
	/// </para>
	/// </param>
	/// <param name="Description">
	/// <para>
	/// A pointer to a caller-supplied UNICODE_STRING structure that contains a NULL-terminated string. The string provides a description of
	/// the transaction. KTM stores a copy of the string and includes the string in messages that it writes to the log stream. The maximum
	/// string length is MAX_TRANSACTION_DESCRIPTION_LENGTH. This parameter is optional and can be <c>NULL</c>.
	/// </para>
	/// </param>
	/// <returns>
	/// <para>
	/// <c>ZwCreateTransaction</c> returns STATUS_SUCCESS if the operation succeeds. Otherwise, this routine might return one of the
	/// following values:
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>Return code</term>
	/// <term>Description</term>
	/// </listheader>
	/// <item>
	/// <term>STATUS_INVALID_PARAMETER</term>
	/// <term>
	/// The CreateOptions parameter contains an invalid flag, the DesiredAccess parameter is zero, or the Description parameter's string is
	/// too long.
	/// </term>
	/// </item>
	/// <item>
	/// <term>STATUS_INSUFFICIENT_RESOURCES</term>
	/// <term>KTM could not allocate system resources (typically memory).</term>
	/// </item>
	/// <item>
	/// <term>STATUS_INVALID_ACL</term>
	/// <term>A security descriptor contains an invalid access control list (ACL).</term>
	/// </item>
	/// <item>
	/// <term>STATUS_INVALID_SID</term>
	/// <term>A security descriptor contains an invalid security identifier (SID).</term>
	/// </item>
	/// <item>
	/// <term>STATUS_OBJECT_NAME_EXISTS</term>
	/// <term>The object name that the ObjectAttributes parameter specifies already exists.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_OBJECT_NAME_INVALID</term>
	/// <term>The object name that the ObjectAttributes parameter specifies is invalid.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_ACCESS_DENIED</term>
	/// <term>The value of the DesiredAccess parameter is invalid.</term>
	/// </item>
	/// </list>
	/// <para>The routine might return other NTSTATUS values.</para>
	/// </returns>
	/// <remarks>
	/// <para>
	/// The caller can use the Uow parameter to specify a UOW identifier for the transaction object. If the caller does not specify a UOW
	/// identifier, KTM generates a GUID and assigns it to the transaction object. The caller can later obtain this GUID by calling ZwQueryInformationTransaction.
	/// </para>
	/// <para>
	/// Typically, you should let KTM generate a GUID for the transaction object, unless your component communicates with another TPS
	/// component that has already generated a UOW identifier for the transaction.
	/// </para>
	/// <para>
	/// To close the transaction handle, the component that called <c>ZwCreateTransaction</c> must call ZwClose. If the last transaction
	/// handle closes before any component calls ZwCommitTransaction for the transaction, KTM rolls back the transaction.
	/// </para>
	/// <para>For more information about how transaction clients should use <c>ZwCreateTransaction</c>, see Creating a Transactional Client.</para>
	/// <para>
	/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
	/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship between
	/// the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
	/// </para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-ntcreatetransaction __kernel_entry NTSYSCALLAPI
	// NTSTATUS NtCreateTransaction( PHANDLE TransactionHandle, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes, LPGUID Uow,
	// HANDLE TmHandle, ULONG CreateOptions, ULONG IsolationLevel, ULONG IsolationFlags, PLARGE_INTEGER Timeout, PUNICODE_STRING Description );
	[DllImport(Lib.NtDll, SetLastError = false, CharSet = CharSet.Auto)]
	[PInvokeData("wdm.h", MSDNShortId = "b4c2dd68-3c1a-46d3-ab9c-be2291ed80f4")]
	public static extern NTStatus NtCreateTransaction(out SafeTransactionHandle TransactionHandle, ACCESS_MASK DesiredAccess, in OBJECT_ATTRIBUTES ObjectAttributes,
		in Guid Uow, SafeTransactionManagerHandle TmHandle, [Optional] uint CreateOptions, [Optional] uint IsolationLevel, [Optional] uint IsolationFlags, in long Timeout,
		[In, Optional, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UnicodeStringMarshaler))] string? Description);

	/// <summary>
	/// <para>The <c>ZwCreateTransaction</c> routine creates a transaction object.</para>
	/// </summary>
	/// <param name="TransactionHandle">
	/// <para>
	/// A pointer to a caller-allocated variable that receives a handle to the new transaction object, if the call to
	/// <c>ZwCreateTransaction</c> succeeds.
	/// </para>
	/// </param>
	/// <param name="DesiredAccess">
	/// <para>
	/// An ACCESS_MASK value that specifies the caller's requested access to the transaction object. In addition to the access rights that
	/// are defined for all kinds of objects (see ACCESS_MASK), the caller can specify any of the following flags for transaction objects.
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>Access mask</term>
	/// <term>Allows the caller to</term>
	/// </listheader>
	/// <item>
	/// <term>TRANSACTION_COMMIT</term>
	/// <term>Commit the transaction (see ZwCommitTransaction).</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_ENLIST</term>
	/// <term>Create an enlistment for the transaction (see ZwCreateEnlistment).</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_PROPAGATE</term>
	/// <term>Do not use.</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_QUERY_INFORMATION</term>
	/// <term>Obtain information about the transaction (see ZwQueryInformationTransaction).</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_ROLLBACK</term>
	/// <term>Roll back the transaction (see ZwRollbackTransaction).</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_SET_INFORMATION</term>
	/// <term>Set information for the transaction (see ZwSetInformationTransaction).</term>
	/// </item>
	/// </list>
	/// <para>
	/// Alternatively, you can specify one or more of the following ACCESS_MASK bitmaps. These bitmaps combine the flags from the previous
	/// table with the STANDARD_RIGHTS_XXX flags that are described on the ACCESS_MASK reference page. You can also combine these bitmaps
	/// with additional flags from the preceding table. The following table shows how the bitmaps correspond to specific access rights.
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>Rights bitmap</term>
	/// <term>Set of specific access rights</term>
	/// </listheader>
	/// <item>
	/// <term>TRANSACTION_GENERIC_READ</term>
	/// <term>STANDARD_RIGHTS_READ, TRANSACTION_QUERY_INFORMATION, and SYNCHRONIZE</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_GENERIC_WRITE</term>
	/// <term>
	/// STANDARD_RIGHTS_WRITE, TRANSACTION_SET_INFORMATION, TRANSACTION_COMMIT, TRANSACTION_ENLIST, TRANSACTION_ROLLBACK,
	/// TRANSACTION_PROPAGATE, TRANSACTION_SAVEPOINT, and SYNCHRONIZE
	/// </term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_GENERIC_EXECUTE</term>
	/// <term>STANDARD_RIGHTS_EXECUTE, TRANSACTION_COMMIT, TRANSACTION_ROLLBACK, and SYNCHRONIZE</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_ALL_ACCESS</term>
	/// <term>STANDARD_RIGHTS_REQUIRED, TRANSACTION_GENERIC_READ, TRANSACTION_GENERIC_WRITE, and TRANSACTION_GENERIC_EXECUTE</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_RESOURCE_MANAGER_RIGHTS</term>
	/// <term>
	/// STANDARD_RIGHTS_WRITE, TRANSACTION_GENERIC_READ, TRANSACTION_SET_INFORMATION, TRANSACTION_ENLIST, TRANSACTION_ROLLBACK,
	/// TRANSACTION_PROPAGATE, and SYNCHRONIZE
	/// </term>
	/// </item>
	/// </list>
	/// <para>Typically, a resource manager specifies TRANSACTION_RESOURCE_MANAGER_RIGHTS.</para>
	/// <para>The DesiredAccess value cannot be zero.</para>
	/// </param>
	/// <param name="ObjectAttributes">
	/// <para>
	/// A pointer to an OBJECT_ATTRIBUTES structure that specifies the object name and other attributes. Use the InitializeObjectAttributes
	/// routine to initialize this structure. If the caller is not running in a system thread context, it must set the OBJ_KERNEL_HANDLE
	/// attribute when it calls <c>InitializeObjectAttributes</c>. This parameter is optional and can be <c>NULL</c>.
	/// </para>
	/// </param>
	/// <param name="Uow">
	/// <para>
	/// A pointer to a GUID that KTM uses as the new transaction object's unit of work (UOW) identifier. This parameter is optional and can
	/// be <c>NULL</c>. If this parameter is <c>NULL</c>, KTM generates a GUID and assigns it to the transaction object. For more
	/// information, see the following Remarks section.
	/// </para>
	/// </param>
	/// <param name="TmHandle">
	/// <para>
	/// A handle to a transaction manager object that was obtained by a previous call to ZwCreateTransactionManager or
	/// ZwOpenTransactionManager. KTM assigns the new transaction object to the specified transaction manager object. If this parameter is
	/// <c>NULL</c>, KTM assigns the new transaction object to a transaction manager later, when a resource manager creates an enlistment
	/// for the transaction.
	/// </para>
	/// </param>
	/// <param name="CreateOptions">
	/// <para>Optional object creation flags. The following table contains the available flags, which are defined in Ktmtypes.h.</para>
	/// <list type="table">
	/// <listheader>
	/// <term>Option flag</term>
	/// <term>Meaning</term>
	/// </listheader>
	/// <item>
	/// <term>TRANSACTION_DO_NOT_PROMOTE</term>
	/// <term>Reserved for future use.</term>
	/// </item>
	/// </list>
	/// </param>
	/// <param name="IsolationLevel">
	/// <para>Reserved for future use. Callers must set this parameter to zero.</para>
	/// </param>
	/// <param name="IsolationFlags">
	/// <para>Reserved for future use. Callers should set this parameter to zero.</para>
	/// </param>
	/// <param name="Timeout">
	/// <para>
	/// A pointer to a time-out value. If the transaction has not been committed by the time specified by this parameter, KTM rolls back the
	/// transaction. The time-out value is expressed in system time units (100-nanosecond intervals), and can specify either an absolute
	/// time or a relative time. If the value pointed to by Timeout is negative, the expiration time is relative to the current system time.
	/// Otherwise, the expiration time is absolute. This pointer is optional and can be <c>NULL</c> if you do not want the transaction to
	/// have a time-out value. If Timeout = <c>NULL</c> or *Timeout = 0, the transaction never times out. (You can also use
	/// ZwSetInformationTransaction to set a time-out value.)
	/// </para>
	/// </param>
	/// <param name="Description">
	/// <para>
	/// A pointer to a caller-supplied UNICODE_STRING structure that contains a NULL-terminated string. The string provides a description of
	/// the transaction. KTM stores a copy of the string and includes the string in messages that it writes to the log stream. The maximum
	/// string length is MAX_TRANSACTION_DESCRIPTION_LENGTH. This parameter is optional and can be <c>NULL</c>.
	/// </para>
	/// </param>
	/// <returns>
	/// <para>
	/// <c>ZwCreateTransaction</c> returns STATUS_SUCCESS if the operation succeeds. Otherwise, this routine might return one of the
	/// following values:
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>Return code</term>
	/// <term>Description</term>
	/// </listheader>
	/// <item>
	/// <term>STATUS_INVALID_PARAMETER</term>
	/// <term>
	/// The CreateOptions parameter contains an invalid flag, the DesiredAccess parameter is zero, or the Description parameter's string is
	/// too long.
	/// </term>
	/// </item>
	/// <item>
	/// <term>STATUS_INSUFFICIENT_RESOURCES</term>
	/// <term>KTM could not allocate system resources (typically memory).</term>
	/// </item>
	/// <item>
	/// <term>STATUS_INVALID_ACL</term>
	/// <term>A security descriptor contains an invalid access control list (ACL).</term>
	/// </item>
	/// <item>
	/// <term>STATUS_INVALID_SID</term>
	/// <term>A security descriptor contains an invalid security identifier (SID).</term>
	/// </item>
	/// <item>
	/// <term>STATUS_OBJECT_NAME_EXISTS</term>
	/// <term>The object name that the ObjectAttributes parameter specifies already exists.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_OBJECT_NAME_INVALID</term>
	/// <term>The object name that the ObjectAttributes parameter specifies is invalid.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_ACCESS_DENIED</term>
	/// <term>The value of the DesiredAccess parameter is invalid.</term>
	/// </item>
	/// </list>
	/// <para>The routine might return other NTSTATUS values.</para>
	/// </returns>
	/// <remarks>
	/// <para>
	/// The caller can use the Uow parameter to specify a UOW identifier for the transaction object. If the caller does not specify a UOW
	/// identifier, KTM generates a GUID and assigns it to the transaction object. The caller can later obtain this GUID by calling ZwQueryInformationTransaction.
	/// </para>
	/// <para>
	/// Typically, you should let KTM generate a GUID for the transaction object, unless your component communicates with another TPS
	/// component that has already generated a UOW identifier for the transaction.
	/// </para>
	/// <para>
	/// To close the transaction handle, the component that called <c>ZwCreateTransaction</c> must call ZwClose. If the last transaction
	/// handle closes before any component calls ZwCommitTransaction for the transaction, KTM rolls back the transaction.
	/// </para>
	/// <para>For more information about how transaction clients should use <c>ZwCreateTransaction</c>, see Creating a Transactional Client.</para>
	/// <para>
	/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
	/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship between
	/// the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
	/// </para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-ntcreatetransaction __kernel_entry NTSYSCALLAPI
	// NTSTATUS NtCreateTransaction( PHANDLE TransactionHandle, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes, LPGUID Uow,
	// HANDLE TmHandle, ULONG CreateOptions, ULONG IsolationLevel, ULONG IsolationFlags, PLARGE_INTEGER Timeout, PUNICODE_STRING Description );
	[DllImport(Lib.NtDll, SetLastError = false, CharSet = CharSet.Auto)]
	[PInvokeData("wdm.h", MSDNShortId = "b4c2dd68-3c1a-46d3-ab9c-be2291ed80f4")]
	public static extern NTStatus NtCreateTransaction(out SafeTransactionHandle TransactionHandle, ACCESS_MASK DesiredAccess, [In, Optional] IntPtr ObjectAttributes,
		[In, Optional] IntPtr Uow, [In, Optional] IntPtr TmHandle, [Optional] uint CreateOptions, [Optional] uint IsolationLevel,
		[Optional] uint IsolationFlags, [In, Optional] IntPtr Timeout, [In, Optional, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UnicodeStringMarshaler))] string? Description);

	/// <summary>
	/// <para>The <c>ZwCreateTransactionManager</c> routine creates a new transaction manager object.</para>
	/// </summary>
	/// <param name="TmHandle">
	/// <para>A pointer to a caller-allocated variable that receives a handle to the new transaction manager object.</para>
	/// </param>
	/// <param name="DesiredAccess">
	/// <para>
	/// An ACCESS_MASK value that specifies the caller's requested access to the transaction manager object. In addition to the access
	/// rights that are defined for all kinds of objects (see ACCESS_MASK), the caller can specify any of the following access right flags
	/// for transaction manager objects.
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>ACCESS_MASK flag</term>
	/// <term>Allows the caller to</term>
	/// </listheader>
	/// <item>
	/// <term>TRANSACTIONMANAGER_CREATE_RM</term>
	/// <term>Create a resource manager (see ZwCreateResourceManager).</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTIONMANAGER_QUERY_INFORMATION</term>
	/// <term>
	/// Obtain information about the transaction manager (see ZwQueryInformationTransactionManager and ZwEnumerateTransactionObject). Also
	/// required for ZwOpenResourceManager, ZwCreateTransaction, and ZwOpenTransaction.)
	/// </term>
	/// </item>
	/// <item>
	/// <term>TRANSACTIONMANAGER_RECOVER</term>
	/// <term>Recover the transaction manager (see ZwRecoverTransactionManager and ZwRollforwardTransactionManager).</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTIONMANAGER_RENAME</term>
	/// <term>Not used.</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTIONMANAGER_SET_INFORMATION</term>
	/// <term>Not used.</term>
	/// </item>
	/// </list>
	/// <para>
	/// Alternatively, you can specify one or more of the following ACCESS_MASK bitmaps. These bitmaps combine the flags from the previous
	/// table with the STANDARD_RIGHTS_XXX flags that are described on the <c>ACCESS_MASK</c> reference page. You can also combine these
	/// bitmaps with additional flags from the preceding table. The following table shows how the bitmaps correspond to specific access rights.
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>Rights bitmap</term>
	/// <term>Set of specific access rights</term>
	/// </listheader>
	/// <item>
	/// <term>TRANSACTIONMANAGER_GENERIC_READ</term>
	/// <term>STANDARD_RIGHTS_READ and TRANSACTIONMANAGER_QUERY_INFORMATION</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTIONMANAGER_GENERIC_WRITE</term>
	/// <term>STANDARD_RIGHTS_WRITE, TRANSACTIONMANAGER_SET_INFORMATION, TRANSACTIONMANAGER_RECOVER, TRANSACTIONMANAGER_RENAME, and TRANSACTIONMANAGER_CREATE_RM</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTIONMANAGER_GENERIC_EXECUTE</term>
	/// <term>STANDARD_RIGHTS_EXECUTE</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTIONMANAGER_ALL_ACCESS</term>
	/// <term>STANDARD_RIGHTS_REQUIRED, TRANSACTIONMANAGER_GENERIC_READ, TRANSACTIONMANAGER_GENERIC_WRITE, and TRANSACTIONMANAGER_GENERIC_EXECUTE</term>
	/// </item>
	/// </list>
	/// </param>
	/// <param name="ObjectAttributes">
	/// <para>
	/// A pointer to an OBJECT_ATTRIBUTES structure that specifies the object name and other attributes. Use the InitializeObjectAttributes
	/// routine to initialize this structure. If the caller is not running in a system thread context, it must set the OBJ_KERNEL_HANDLE
	/// attribute when it calls <c>InitializeObjectAttributes</c>. This parameter is optional and can be <c>NULL</c>.
	/// </para>
	/// </param>
	/// <param name="LogFileName">
	/// <para>
	/// A pointer to a UNICODE_STRING structure that contains the path and file name of a CLFS log file stream to be associated with the
	/// transaction manager object. This parameter must be <c>NULL</c> if the CreateOptions parameter is TRANSACTION_MANAGER_VOLATILE.
	/// Otherwise, this parameter must be non- <c>NULL</c>. For more information, see the following Remarks section.
	/// </para>
	/// </param>
	/// <param name="CreateOptions">
	/// <para>Optional object creation flags. The following table contains the available flags, which are defined in Ktmtypes.h.</para>
	/// <list type="table">
	/// <listheader>
	/// <term>Option flag</term>
	/// <term>Meaning</term>
	/// </listheader>
	/// <item>
	/// <term>TRANSACTION_MANAGER_VOLATILE</term>
	/// <term>The transaction manager object will be volatile. Therefore, it will not use a log file.</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_MANAGER_COMMIT_DEFAULT</term>
	/// <term>For internal use only.</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_MANAGER_COMMIT_SYSTEM_VOLUME</term>
	/// <term>For internal use only.</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_MANAGER_COMMIT_SYSTEM_HIVES</term>
	/// <term>For internal use only.</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_MANAGER_COMMIT_LOWEST</term>
	/// <term>For internal use only.</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_MANAGER_CORRUPT_FOR_RECOVERY</term>
	/// <term>For internal use only.</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_MANAGER_CORRUPT_FOR_PROGRESS</term>
	/// <term>For internal use only.</term>
	/// </item>
	/// </list>
	/// </param>
	/// <param name="CommitStrength">
	/// <para>Reserved for future use. This parameter must be zero.</para>
	/// </param>
	/// <returns>
	/// <para>
	/// <c>ZwCreateTransactionManager</c> returns STATUS_SUCCESS if the operation succeeds. Otherwise, this routine might return one of the
	/// following values:
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>Return code</term>
	/// <term>Description</term>
	/// </listheader>
	/// <item>
	/// <term>STATUS_INVALID_PARAMETER</term>
	/// <term>The value of an input parameter is invalid.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_INSUFFICIENT_RESOURCES</term>
	/// <term>KTM could not allocate system resources (typically memory).</term>
	/// </item>
	/// <item>
	/// <term>STATUS_LOG_CORRUPTION_DETECTED</term>
	/// <term>KTM encountered an error while creating or opening the log file.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_INVALID_ACL</term>
	/// <term>A security descriptor contains an invalid access control list (ACL).</term>
	/// </item>
	/// <item>
	/// <term>STATUS_INVALID_SID</term>
	/// <term>A security descriptor contains an invalid security identifier (SID).</term>
	/// </item>
	/// <item>
	/// <term>STATUS_OBJECT_NAME_EXISTS</term>
	/// <term>The object name that the ObjectAttributes parameter specifies already exists.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_OBJECT_NAME_COLLISION</term>
	/// <term>The operating system detected a duplicate object name. The error might indicate that the log stream is already being used.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_OBJECT_NAME_INVALID</term>
	/// <term>The object name that the ObjectAttributes parameter specifies is invalid.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_ACCESS_DENIED</term>
	/// <term>The value of the DesiredAccess parameter is invalid.</term>
	/// </item>
	/// </list>
	/// <para>The routine might return other NTSTATUS values.</para>
	/// </returns>
	/// <remarks>
	/// <para>
	/// If the log file stream that the LogFileName parameter specifies does not exist, KTM calls CLFS to create the stream. If the stream
	/// already exists, KTM calls CLFS to open the stream.
	/// </para>
	/// <para>Your TPS component must call ZwRecoverTransactionManager after it has called <c>ZwCreateTransactionManager</c></para>
	/// <para>
	/// If your TPS component specifies the TRANSACTION_MANAGER_VOLATILE flag in the CreateOptions parameter, all resource managers that are
	/// associated with the transaction manager object must specify the RESOURCE_MANAGER_VOLATILE flag when they call ZwCreateResourceManager.
	/// </para>
	/// <para>A TPS component that calls <c>ZwCreateTransactionManager</c> must eventually call ZwClose to close the object handle.</para>
	/// <para>For more information about how use <c>ZwCreateTransactionManager</c>, see Creating a Resource Manager.</para>
	/// <para>
	/// <c>NtCreateTransactionManager</c> and <c>ZwCreateTransactionManager</c> are two versions of the same Windows Native System Services routine.
	/// </para>
	/// <para>
	/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
	/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship between
	/// the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
	/// </para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-ntcreatetransactionmanager __kernel_entry
	// NTSYSCALLAPI NTSTATUS NtCreateTransactionManager( PHANDLE TmHandle, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes,
	// PUNICODE_STRING LogFileName, ULONG CreateOptions, ULONG CommitStrength );
	[DllImport(Lib.NtDll, SetLastError = false, CharSet = CharSet.Auto)]
	[PInvokeData("wdm.h", MSDNShortId = "9c9f0a8b-7add-4ab1-835d-39f508ce32a9")]
	public static extern NTStatus NtCreateTransactionManager(out SafeTransactionManagerHandle TmHandle, ACCESS_MASK DesiredAccess, in OBJECT_ATTRIBUTES ObjectAttributes,
		[In, Optional, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UnicodeStringMarshaler))] string? LogFileName, [Optional] uint CreateOptions, [Optional] uint CommitStrength);

	/// <summary>
	/// <para>The <c>ZwCreateTransactionManager</c> routine creates a new transaction manager object.</para>
	/// </summary>
	/// <param name="TmHandle">
	/// <para>A pointer to a caller-allocated variable that receives a handle to the new transaction manager object.</para>
	/// </param>
	/// <param name="DesiredAccess">
	/// <para>
	/// An ACCESS_MASK value that specifies the caller's requested access to the transaction manager object. In addition to the access
	/// rights that are defined for all kinds of objects (see ACCESS_MASK), the caller can specify any of the following access right flags
	/// for transaction manager objects.
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>ACCESS_MASK flag</term>
	/// <term>Allows the caller to</term>
	/// </listheader>
	/// <item>
	/// <term>TRANSACTIONMANAGER_CREATE_RM</term>
	/// <term>Create a resource manager (see ZwCreateResourceManager).</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTIONMANAGER_QUERY_INFORMATION</term>
	/// <term>
	/// Obtain information about the transaction manager (see ZwQueryInformationTransactionManager and ZwEnumerateTransactionObject). Also
	/// required for ZwOpenResourceManager, ZwCreateTransaction, and ZwOpenTransaction.)
	/// </term>
	/// </item>
	/// <item>
	/// <term>TRANSACTIONMANAGER_RECOVER</term>
	/// <term>Recover the transaction manager (see ZwRecoverTransactionManager and ZwRollforwardTransactionManager).</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTIONMANAGER_RENAME</term>
	/// <term>Not used.</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTIONMANAGER_SET_INFORMATION</term>
	/// <term>Not used.</term>
	/// </item>
	/// </list>
	/// <para>
	/// Alternatively, you can specify one or more of the following ACCESS_MASK bitmaps. These bitmaps combine the flags from the previous
	/// table with the STANDARD_RIGHTS_XXX flags that are described on the <c>ACCESS_MASK</c> reference page. You can also combine these
	/// bitmaps with additional flags from the preceding table. The following table shows how the bitmaps correspond to specific access rights.
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>Rights bitmap</term>
	/// <term>Set of specific access rights</term>
	/// </listheader>
	/// <item>
	/// <term>TRANSACTIONMANAGER_GENERIC_READ</term>
	/// <term>STANDARD_RIGHTS_READ and TRANSACTIONMANAGER_QUERY_INFORMATION</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTIONMANAGER_GENERIC_WRITE</term>
	/// <term>STANDARD_RIGHTS_WRITE, TRANSACTIONMANAGER_SET_INFORMATION, TRANSACTIONMANAGER_RECOVER, TRANSACTIONMANAGER_RENAME, and TRANSACTIONMANAGER_CREATE_RM</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTIONMANAGER_GENERIC_EXECUTE</term>
	/// <term>STANDARD_RIGHTS_EXECUTE</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTIONMANAGER_ALL_ACCESS</term>
	/// <term>STANDARD_RIGHTS_REQUIRED, TRANSACTIONMANAGER_GENERIC_READ, TRANSACTIONMANAGER_GENERIC_WRITE, and TRANSACTIONMANAGER_GENERIC_EXECUTE</term>
	/// </item>
	/// </list>
	/// </param>
	/// <param name="ObjectAttributes">
	/// <para>
	/// A pointer to an OBJECT_ATTRIBUTES structure that specifies the object name and other attributes. Use the InitializeObjectAttributes
	/// routine to initialize this structure. If the caller is not running in a system thread context, it must set the OBJ_KERNEL_HANDLE
	/// attribute when it calls <c>InitializeObjectAttributes</c>. This parameter is optional and can be <c>NULL</c>.
	/// </para>
	/// </param>
	/// <param name="LogFileName">
	/// <para>
	/// A pointer to a UNICODE_STRING structure that contains the path and file name of a CLFS log file stream to be associated with the
	/// transaction manager object. This parameter must be <c>NULL</c> if the CreateOptions parameter is TRANSACTION_MANAGER_VOLATILE.
	/// Otherwise, this parameter must be non- <c>NULL</c>. For more information, see the following Remarks section.
	/// </para>
	/// </param>
	/// <param name="CreateOptions">
	/// <para>Optional object creation flags. The following table contains the available flags, which are defined in Ktmtypes.h.</para>
	/// <list type="table">
	/// <listheader>
	/// <term>Option flag</term>
	/// <term>Meaning</term>
	/// </listheader>
	/// <item>
	/// <term>TRANSACTION_MANAGER_VOLATILE</term>
	/// <term>The transaction manager object will be volatile. Therefore, it will not use a log file.</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_MANAGER_COMMIT_DEFAULT</term>
	/// <term>For internal use only.</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_MANAGER_COMMIT_SYSTEM_VOLUME</term>
	/// <term>For internal use only.</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_MANAGER_COMMIT_SYSTEM_HIVES</term>
	/// <term>For internal use only.</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_MANAGER_COMMIT_LOWEST</term>
	/// <term>For internal use only.</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_MANAGER_CORRUPT_FOR_RECOVERY</term>
	/// <term>For internal use only.</term>
	/// </item>
	/// <item>
	/// <term>TRANSACTION_MANAGER_CORRUPT_FOR_PROGRESS</term>
	/// <term>For internal use only.</term>
	/// </item>
	/// </list>
	/// </param>
	/// <param name="CommitStrength">
	/// <para>Reserved for future use. This parameter must be zero.</para>
	/// </param>
	/// <returns>
	/// <para>
	/// <c>ZwCreateTransactionManager</c> returns STATUS_SUCCESS if the operation succeeds. Otherwise, this routine might return one of the
	/// following values:
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>Return code</term>
	/// <term>Description</term>
	/// </listheader>
	/// <item>
	/// <term>STATUS_INVALID_PARAMETER</term>
	/// <term>The value of an input parameter is invalid.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_INSUFFICIENT_RESOURCES</term>
	/// <term>KTM could not allocate system resources (typically memory).</term>
	/// </item>
	/// <item>
	/// <term>STATUS_LOG_CORRUPTION_DETECTED</term>
	/// <term>KTM encountered an error while creating or opening the log file.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_INVALID_ACL</term>
	/// <term>A security descriptor contains an invalid access control list (ACL).</term>
	/// </item>
	/// <item>
	/// <term>STATUS_INVALID_SID</term>
	/// <term>A security descriptor contains an invalid security identifier (SID).</term>
	/// </item>
	/// <item>
	/// <term>STATUS_OBJECT_NAME_EXISTS</term>
	/// <term>The object name that the ObjectAttributes parameter specifies already exists.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_OBJECT_NAME_COLLISION</term>
	/// <term>The operating system detected a duplicate object name. The error might indicate that the log stream is already being used.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_OBJECT_NAME_INVALID</term>
	/// <term>The object name that the ObjectAttributes parameter specifies is invalid.</term>
	/// </item>
	/// <item>
	/// <term>STATUS_ACCESS_DENIED</term>
	/// <term>The value of the DesiredAccess parameter is invalid.</term>
	/// </item>
	/// </list>
	/// <para>The routine might return other NTSTATUS values.</para>
	/// </returns>
	/// <remarks>
	/// <para>
	/// If the log file stream that the LogFileName parameter specifies does not exist, KTM calls CLFS to create the stream. If the stream
	/// already exists, KTM calls CLFS to open the stream.
	/// </para>
	/// <para>Your TPS component must call ZwRecoverTransactionManager after it has called <c>ZwCreateTransactionManager</c></para>
	/// <para>
	/// If your TPS component specifies the TRANSACTION_MANAGER_VOLATILE flag in the CreateOptions parameter, all resource managers that are
	/// associated with the transaction manager object must specify the RESOURCE_MANAGER_VOLATILE flag when they call ZwCreateResourceManager.
	/// </para>
	/// <para>A TPS component that calls <c>ZwCreateTransactionManager</c> must eventually call ZwClose to close the object handle.</para>
	/// <para>For more information about how use <c>ZwCreateTransactionManager</c>, see Creating a Resource Manager.</para>
	/// <para>
	/// <c>NtCreateTransactionManager</c> and <c>ZwCreateTransactionManager</c> are two versions of the same Windows Native System Services routine.
	/// </para>
	/// <para>
	/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
	/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship between
	/// the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
	/// </para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-ntcreatetransactionmanager __kernel_entry
	// NTSYSCALLAPI NTSTATUS NtCreateTransactionManager( PHANDLE TmHandle, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes,
	// PUNICODE_STRING LogFileName, ULONG CreateOptions, ULONG CommitStrength );
	[DllImport(Lib.NtDll, SetLastError = false, CharSet = CharSet.Auto)]
	[PInvokeData("wdm.h", MSDNShortId = "9c9f0a8b-7add-4ab1-835d-39f508ce32a9")]
	public static extern NTStatus NtCreateTransactionManager(out SafeTransactionManagerHandle TmHandle, ACCESS_MASK DesiredAccess, [In, Optional] IntPtr ObjectAttributes,
		[In, Optional, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UnicodeStringMarshaler))] string? LogFileName, [Optional] uint CreateOptions, [Optional] uint CommitStrength);

	/// <summary>
	/// <para>The <c>ZwQueryKey</c> routine provides information about the class of a registry key, and the number and sizes of its subkeys.</para>
	/// </summary>
	/// <param name="KeyHandle">
	/// <para>Handle to the registry key to obtain information about. This handle is created by a successful call to ZwCreateKey or ZwOpenKey.</para>
	/// </param>
	/// <param name="KeyInformationClass">
	/// <para>Specifies a KEY_INFORMATION_CLASS value that determines the type of information returned in the KeyInformation buffer.</para>
	/// </param>
	/// <param name="KeyInformation">
	/// <para>Pointer to a caller-allocated buffer that receives the requested information.</para>
	/// </param>
	/// <param name="Length">
	/// <para>Specifies the size, in bytes, of the KeyInformation buffer.</para>
	/// </param>
	/// <param name="ResultLength">
	/// <para>
	/// Pointer to a variable that receives the size, in bytes, of the requested key information. If <c>ZwQueryKey</c> returns
	/// STATUS_SUCCESS, the variable contains the amount of data returned. If <c>ZwQueryKey</c> returns STATUS_BUFFER_OVERFLOW or
	/// STATUS_BUFFER_TOO_SMALL, you can use the value of the variable to determine the required buffer size.
	/// </para>
	/// </param>
	/// <returns>
	/// <para>
	/// <c>ZwQueryKey</c> returns STATUS_SUCCESS on success, or the appropriate error code on failure. Possible error code values include:
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>Return code</term>
	/// <term>Description</term>
	/// </listheader>
	/// <item>
	/// <term>STATUS_BUFFER_OVERFLOW</term>
	/// <term>
	/// The buffer supplied is too small, and only partial data has been written to the buffer. *ResultLength is set to the minimum size
	/// required to hold the requested information.
	/// </term>
	/// </item>
	/// <item>
	/// <term>STATUS_BUFFER_TOO_SMALL</term>
	/// <term>
	/// The buffer supplied is too small, and no data has been written to the buffer. *ResultLength is set to the minimum size required to
	/// hold the requested information.
	/// </term>
	/// </item>
	/// <item>
	/// <term>STATUS_INVALID_PARAMETER</term>
	/// <term>The KeyInformationClass parameter is not a valid KEY_INFORMATION_CLASS value.</term>
	/// </item>
	/// </list>
	/// </returns>
	/// <remarks>
	/// <para>
	/// The KeyHandle passed to <c>ZwQueryKey</c> must have been opened with KEY_QUERY_VALUE access. This is accomplished by passing
	/// KEY_QUERY_VALUE, KEY_READ, or KEY_ALL_ACCESS as the DesiredAccess parameter to ZwCreateKey or ZwOpenKey.
	/// </para>
	/// <para>
	/// <c>ZwQueryKey</c> can be used to obtain information that you can use to allocate buffers to hold registry data, such as the maximum
	/// size of a key's value entries or subkey names, or the number of subkeys. For example, you can call <c>ZwQueryKey</c>, use the
	/// returned information to allocate a buffer for a subkey, call ZwEnumerateKey to get the name of the subkey, and pass that name to an
	/// <c>Rtl</c><c>Xxx</c><c>Registry</c> routine.
	/// </para>
	/// <para>For more information about working with registry keys, see Using the Registry in a Driver.</para>
	/// <para>
	/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
	/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship between
	/// the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
	/// </para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-zwquerykey NTSYSAPI NTSTATUS ZwQueryKey( HANDLE
	// KeyHandle, KEY_INFORMATION_CLASS KeyInformationClass, PVOID KeyInformation, ULONG Length, PULONG ResultLength );
	[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true, CharSet = CharSet.Unicode)]
	[PInvokeData("wdm.h", MSDNShortId = "3b2d3a8b-a21f-4067-a1f0-9aa66c1973f5")]
	public static extern NTStatus NtQueryKey(HKEY KeyHandle, KEY_INFORMATION_CLASS KeyInformationClass, [Out] SafeHGlobalHandle KeyInformation, uint Length, out uint ResultLength);

	/// <summary>Gets version information about the currently running operating system.</summary>
	/// <param name="lpVersionInformation">
	/// Pointer to either a <c>RTL_OSVERSIONINFOW</c> structure or a <c>RTL_OSVERSIONINFOEXW</c> structure that contains the version
	/// information about the currently running operating system. A caller specifies which input structure is used by setting the
	/// <c>dwOSVersionInfoSize</c> member of the structure to the size in bytes of the structure that is used.
	/// </param>
	/// <returns>Returns STATUS_SUCCESS.</returns>
	/// <remarks>
	/// <para>
	/// <c>RtlGetVersion</c> is the equivalent of the <c>GetVersionEx</c> function in the Windows SDK. See the example in the Windows SDK
	/// that shows how to get the system version.
	/// </para>
	/// <para>
	/// When using <c>RtlGetVersion</c> to determine whether a particular version of the operating system is running, a caller should check
	/// for version numbers that are greater than or equal to the required version number. This ensures that a version test succeeds for
	/// later versions of Windows.
	/// </para>
	/// <para>
	/// Because operating system features can be added in a redistributable DLL, checking only the major and minor version numbers is not
	/// the most reliable way to verify the presence of a specific system feature. A driver should use <c>RtlVerifyVersionInfo</c> to test
	/// for the presence of a specific system feature.
	/// </para>
	/// </remarks>
	// https://learn.microsoft.com/en-us/windows/win32/devnotes/rtlgetversion NTSTATUS RtlGetVersion( _Out_&#194; PRTL_OSVERSIONINFOW
	// lpVersionInformation );
	[PInvokeData("Ntddk.h")]
	[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true)]
	public static extern NTStatus RtlGetVersion(out OSVERSIONINFOW lpVersionInformation);

	/// <summary>
	/// <para>
	/// A driver sets an IRP's I/O status block to indicate the final status of an I/O request, before calling IoCompleteRequest for the IRP.
	/// </para>
	/// </summary>
	/// <remarks>
	/// <para>
	/// Unless a driver's dispatch routine completes an IRP with an error status value, the lowest-level driver in the chain frequently sets
	/// the IRP's I/O status block to the values that will be returned to the original requester of the I/O operation.
	/// </para>
	/// <para>
	/// The IoCompletion routines of higher-level drivers usually check the I/O status block in IRPs completed by lower drivers. By design,
	/// the I/O status block in an IRP is the only information passed back from the underlying device driver to all higher-level drivers'
	/// IoCompletion routines.
	/// </para>
	/// <para>
	/// The operating system implements support routines that write <c>IO_STATUS_BLOCK</c> values to caller-supplied output buffers. For
	/// example, see ZwOpenFile or NtOpenFile. These routines return status codes that might not match the status codes in the
	/// <c>IO_STATUS_BLOCK</c> structures. If one of these routines returns STATUS_PENDING, the caller should wait for the I/O operation to
	/// complete, and then check the status code in the <c>IO_STATUS_BLOCK</c> structure to determine the final status of the operation. If
	/// the routine returns a status code other than STATUS_PENDING, the caller should rely on this status code instead of the status code
	/// in the <c>IO_STATUS_BLOCK</c> structure.
	/// </para>
	/// <para>For more information, see I/O Status Blocks.</para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/ns-wdm-_io_status_block typedef struct _IO_STATUS_BLOCK {
	// union { NTSTATUS Status; PVOID Pointer; } DUMMYUNIONNAME; ULONG_PTR Information; } IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
	[PInvokeData("wdm.h", MSDNShortId = "1ce2b1d0-a8b2-4a05-8895-e13802690a7b")]
	[StructLayout(LayoutKind.Sequential)]
	public struct IO_STATUS_BLOCK
	{
		/// <summary>Reserved. For internal use only.</summary>
		public IntPtr Pointer;

		/// <summary>
		/// This is the completion status, either STATUS_SUCCESS if the requested operation was completed successfully or an informational,
		/// warning, or error STATUS_XXX value. For more information, see Using NTSTATUS values.
		/// </summary>
		public NTStatus Status { get => (NTStatus)unchecked((uint)Pointer.ToInt64()); set => Pointer = (IntPtr)unchecked((int)(uint)value); }

		/// <summary>
		/// This is set to a request-dependent value. For example, on successful completion of a transfer request, this is set to the number
		/// of bytes transferred. If a transfer request is completed with another STATUS_XXX, this member is set to zero.
		/// </summary>
		public IntPtr Information;
	}

	/// <summary>
	/// <para>The <c>KEY_BASIC_INFORMATION</c> structure defines a subset of the full information that is available for a registry key.</para>
	/// </summary>
	/// <remarks>
	/// <para>
	/// The ZwEnumerateKey and ZwQueryKey routines use the <c>KEY_BASIC_INFORMATION</c> structure to contain the basic information for a
	/// registry key. When the KeyInformationClass parameter of either routine is <c>KeyBasicInformation</c>, the KeyInformation buffer is
	/// treated as a <c>KEY_BASIC_INFORMATION</c> structure. For more information about the <c>KeyBasicInformation</c> enumeration value,
	/// see KEY_INFORMATION_CLASS.
	/// </para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/ns-wdm-_key_basic_information typedef struct
	// _KEY_BASIC_INFORMATION { LARGE_INTEGER LastWriteTime; ULONG TitleIndex; ULONG NameLength; WCHAR Name[1]; } KEY_BASIC_INFORMATION, *PKEY_BASIC_INFORMATION;
	[PInvokeData("wdm.h", MSDNShortId = "789c60b6-a5a4-4570-bb0c-acfe1166a302")]
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
	public struct KEY_BASIC_INFORMATION
	{
		/// <summary>
		/// <para>
		/// The last time this key or any of its values changed. This time value is expressed in absolute system time format. Absolute
		/// system time is the number of 100-nanosecond intervals since the start of the year 1601 in the Gregorian calendar.
		/// </para>
		/// </summary>
		public long LastWriteTime;

		/// <summary>
		/// <para>Device and intermediate drivers should ignore this member.</para>
		/// </summary>
		public uint TitleIndex;

		/// <summary>
		/// <para>The size, in bytes, of the key name string in the <c>Name</c> array.</para>
		/// </summary>
		public uint NameLength;

		/// <summary>
		/// <para>
		/// An array of wide characters that contains the name of the registry key. This character string is null-terminated. Only the first
		/// element in this array is included in the <c>KEY_BASIC_INFORMATION</c> structure definition. The storage for the remaining
		/// elements in the array immediately follows this element.
		/// </para>
		/// </summary>
		public StrPtrUni Name;
	}

	/// <summary>
	/// <para>
	/// The <c>KEY_FULL_INFORMATION</c> structure defines the information available for a registry key, including information about its
	/// subkeys and the maximum length for their names and value entries. This information can be used to size buffers to get the names of
	/// subkeys and their value entries.
	/// </para>
	/// </summary>
	/// <remarks>
	/// <para>
	/// The ZwEnumerateKey and ZwQueryKey routines use the <c>KEY_FULL_INFORMATION</c> structure to contain the full information for a
	/// registry key. When the KeyInformationClass parameter of either routine is <c>KeyFullInformation</c>, the KeyInformation buffer is
	/// treated as a <c>KEY_FULL_INFORMATION</c> structure. For more information about the <c>KeyFullInformation</c> enumeration value, see KEY_INFORMATION_CLASS.
	/// </para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/ns-wdm-_key_full_information typedef struct
	// _KEY_FULL_INFORMATION { LARGE_INTEGER LastWriteTime; ULONG TitleIndex; ULONG ClassOffset; ULONG ClassLength; ULONG SubKeys; ULONG
	// MaxNameLen; ULONG MaxClassLen; ULONG Values; ULONG MaxValueNameLen; ULONG MaxValueDataLen; WCHAR Class[1]; } KEY_FULL_INFORMATION, *PKEY_FULL_INFORMATION;
	[PInvokeData("wdm.h", MSDNShortId = "dd099435-e3e3-4d78-a829-0f12f2db46d9")]
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
	public struct KEY_FULL_INFORMATION
	{
		/// <summary>
		/// <para>
		/// The last time this key or any of its values changed. This time value is expressed in absolute system time format. Absolute
		/// system time is the number of 100-nanosecond intervals since the start of the year 1601 in the Gregorian calendar.
		/// </para>
		/// </summary>
		public long LastWriteTime;

		/// <summary>
		/// <para>Device and intermediate drivers should ignore this member.</para>
		/// </summary>
		public uint TitleIndex;

		/// <summary>
		/// <para>The byte offset from the start of this structure to the <c>Class</c> member.</para>
		/// </summary>
		public uint ClassOffset;

		/// <summary>
		/// <para>The size, in bytes, of the key class name string in the <c>Class</c> array.</para>
		/// </summary>
		public uint ClassLength;

		/// <summary>
		/// <para>The number of subkeys for this key.</para>
		/// </summary>
		public uint SubKeys;

		/// <summary>
		/// <para>The maximum size, in bytes, of any name for a subkey.</para>
		/// </summary>
		public uint MaxNameLen;

		/// <summary>
		/// <para>The maximum size, in bytes, of a class name.</para>
		/// </summary>
		public uint MaxClassLen;

		/// <summary>
		/// <para>The number of value entries for this key.</para>
		/// </summary>
		public uint Values;

		/// <summary>
		/// <para>The maximum size, in bytes, of a value entry name.</para>
		/// </summary>
		public uint MaxValueNameLen;

		/// <summary>
		/// <para>The maximum size, in bytes, of a value entry data field.</para>
		/// </summary>
		public uint MaxValueDataLen;

		/// <summary>
		/// <para>
		/// An array of wide characters that contains the name of the class of the key. This character string is null-terminated. Only the
		/// first element in this array is included in the <c>KEY_FULL_INFORMATION</c> structure definition. The storage for the remaining
		/// elements in the array immediately follows this element.
		/// </para>
		/// </summary>
		public StrPtrUni Class;
	}

	/// <summary>
	/// <para>The <c>KEY_NODE_INFORMATION</c> structure defines the basic information available for a registry (sub)key.</para>
	/// </summary>
	/// <remarks>
	/// <para>
	/// The ZwEnumerateKey and ZwQueryKey routines use the <c>KEY_NODE_INFORMATION</c> structure to contain the registry key name and key
	/// class name. When the KeyInformationClass parameter of either routine is <c>KeyNodeInformation</c>, the KeyInformation buffer is
	/// treated as a <c>KEY_NODE_INFORMATION</c> structure. For more information about the <c>KeyNodeInformation</c> enumeration value, see KEY_INFORMATION_CLASS.
	/// </para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/ns-wdm-_key_node_information typedef struct
	// _KEY_NODE_INFORMATION { LARGE_INTEGER LastWriteTime; ULONG TitleIndex; ULONG ClassOffset; ULONG ClassLength; ULONG NameLength; WCHAR
	// Name[1]; } KEY_NODE_INFORMATION, *PKEY_NODE_INFORMATION;
	[PInvokeData("wdm.h", MSDNShortId = "2eed1a3d-fc40-4416-ad61-d82bf4fb69a1")]
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
	public struct KEY_NODE_INFORMATION
	{
		/// <summary>
		/// <para>
		/// The last time this key or any of its values changed. This time value is expressed in absolute system time format. Absolute
		/// system time is the number of 100-nanosecond intervals since the start of the year 1601 in the Gregorian calendar.
		/// </para>
		/// </summary>
		public long LastWriteTime;

		/// <summary>
		/// <para>Device and intermediate drivers should ignore this member.</para>
		/// </summary>
		public uint TitleIndex;

		/// <summary>
		/// <para>
		/// The byte offset from the start of this structure to the class name string, which is located in the <c>Name</c> array immediately
		/// following the key name string. Like the key name string, the class name string is not null-terminated.
		/// </para>
		/// </summary>
		public uint ClassOffset;

		/// <summary>
		/// <para>The size, in bytes, in the class name string.</para>
		/// </summary>
		public uint ClassLength;

		/// <summary>
		/// <para>The size, in bytes, of the key name string contained in the <c>Name</c> array.</para>
		/// </summary>
		public uint NameLength;

		/// <summary>
		/// <para>
		/// An array of wide characters that contains the name of the registry key. This character string is null-terminated. Only the first
		/// element in this array is included in the <c>KEY_NODE_INFORMATION</c> structure definition. The storage for the remaining
		/// elements in the array immediately follows this element.
		/// </para>
		/// </summary>
		public StrPtrUni Name;
	}

	/// <summary>
	/// <para>
	/// Contains operating system version information. The information includes major and minor version numbers, a build number, a platform
	/// identifier, and descriptive text about the operating system. This structure is used with the GetVersionEx function.
	/// </para>
	/// <para>To obtain additional version information, use the OSVERSIONINFOEX structure with GetVersionEx instead.</para>
	/// </summary>
	/// <remarks>
	/// <para>
	/// Relying on version information is not the best way to test for a feature. Instead, refer to the documentation for the feature of
	/// interest. For more information on common techniques for feature detection, see Operating System Version.
	/// </para>
	/// <para>
	/// If you must require a particular operating system, be sure to use it as a minimum supported version, rather than design the test for
	/// the one operating system. This way, your detection code will continue to work on future versions of Windows.
	/// </para>
	/// <para>
	/// The following table summarizes the values returned by supported versions of Windows. Use the information in the column labeled
	/// "Other" to distinguish between operating systems with identical version numbers.
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <description>Operating system</description>
	/// <description>Version number</description>
	/// <description><c>dwMajorVersion</c></description>
	/// <description><c>dwMinorVersion</c></description>
	/// <description>Other</description>
	/// </listheader>
	/// <item>
	/// <description>WindowsÂ 10</description>
	/// <description>10.0*</description>
	/// <description>10</description>
	/// <description>0</description>
	/// <description>OSVERSIONINFOEX.wProductType == VER_NT_WORKSTATION</description>
	/// </item>
	/// <item>
	/// <description>Windows ServerÂ 2016</description>
	/// <description>10.0*</description>
	/// <description>10</description>
	/// <description>0</description>
	/// <description>OSVERSIONINFOEX.wProductType != VER_NT_WORKSTATION</description>
	/// </item>
	/// <item>
	/// <description>WindowsÂ 8.1</description>
	/// <description>6.3*</description>
	/// <description>6</description>
	/// <description>3</description>
	/// <description>OSVERSIONINFOEX.wProductType == VER_NT_WORKSTATION</description>
	/// </item>
	/// <item>
	/// <description>Windows ServerÂ 2012Â R2</description>
	/// <description>6.3*</description>
	/// <description>6</description>
	/// <description>3</description>
	/// <description>OSVERSIONINFOEX.wProductType != VER_NT_WORKSTATION</description>
	/// </item>
	/// <item>
	/// <description>WindowsÂ 8</description>
	/// <description>6.2</description>
	/// <description>6</description>
	/// <description>2</description>
	/// <description>OSVERSIONINFOEX.wProductType == VER_NT_WORKSTATION</description>
	/// </item>
	/// <item>
	/// <description>Windows ServerÂ 2012</description>
	/// <description>6.2</description>
	/// <description>6</description>
	/// <description>2</description>
	/// <description>OSVERSIONINFOEX.wProductType != VER_NT_WORKSTATION</description>
	/// </item>
	/// <item>
	/// <description>WindowsÂ 7</description>
	/// <description>6.1</description>
	/// <description>6</description>
	/// <description>1</description>
	/// <description>OSVERSIONINFOEX.wProductType == VER_NT_WORKSTATION</description>
	/// </item>
	/// <item>
	/// <description>Windows ServerÂ 2008Â R2</description>
	/// <description>6.1</description>
	/// <description>6</description>
	/// <description>1</description>
	/// <description>OSVERSIONINFOEX.wProductType != VER_NT_WORKSTATION</description>
	/// </item>
	/// <item>
	/// <description>Windows ServerÂ 2008</description>
	/// <description>6.0</description>
	/// <description>6</description>
	/// <description>0</description>
	/// <description>OSVERSIONINFOEX.wProductType != VER_NT_WORKSTATION</description>
	/// </item>
	/// <item>
	/// <description>WindowsÂ Vista</description>
	/// <description>6.0</description>
	/// <description>6</description>
	/// <description>0</description>
	/// <description>OSVERSIONINFOEX.wProductType == VER_NT_WORKSTATION</description>
	/// </item>
	/// <item>
	/// <description>Windows ServerÂ 2003Â R2</description>
	/// <description>5.2</description>
	/// <description>5</description>
	/// <description>2</description>
	/// <description>GetSystemMetrics(SM_SERVERR2) != 0</description>
	/// </item>
	/// <item>
	/// <description>Windows ServerÂ 2003</description>
	/// <description>5.2</description>
	/// <description>5</description>
	/// <description>2</description>
	/// <description>GetSystemMetrics(SM_SERVERR2) == 0</description>
	/// </item>
	/// <item>
	/// <description>WindowsÂ XP</description>
	/// <description>5.1</description>
	/// <description>5</description>
	/// <description>1</description>
	/// <description>Not applicable</description>
	/// </item>
	/// <item>
	/// <description>WindowsÂ 2000</description>
	/// <description>5.0</description>
	/// <description>5</description>
	/// <description>0</description>
	/// <description>Not applicable</description>
	/// </item>
	/// <item>
	/// <description>
	/// <c>*</c> For applications that have been manifested for WindowsÂ 8.1 or WindowsÂ 10. Applications not manifested for WindowsÂ 8.1 or
	/// WindowsÂ 10 will return the WindowsÂ 8 OS version value (6.2). To manifest your applications for WindowsÂ 8.1 or WindowsÂ 10, refer
	/// to Targeting your application for Windows.
	/// </description>
	/// </item>
	/// </list>
	/// <para>Â</para>
	/// <para>Examples</para>
	/// <para>For an example, see Getting the System Version.</para>
	/// <para>
	/// <para>Note</para>
	/// <para>
	/// The winnt.h header defines OSVERSIONINFO as an alias which automatically selects the ANSI or Unicode version of this function based
	/// on the definition of the UNICODE preprocessor constant. Mixing usage of the encoding-neutral alias with code that not
	/// encoding-neutral can lead to mismatches that result in compilation or runtime errors. For more information, see Conventions for
	/// Function Prototypes.
	/// </para>
	/// </para>
	/// </remarks>
	// https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-osversioninfow typedef struct _OSVERSIONINFOW { DWORD
	// dwOSVersionInfoSize; DWORD dwMajorVersion; DWORD dwMinorVersion; DWORD dwBuildNumber; DWORD dwPlatformId; WCHAR szCSDVersion[128]; }
	// OSVERSIONINFOW, *POSVERSIONINFOW, *LPOSVERSIONINFOW, RTL_OSVERSIONINFOW, *PRTL_OSVERSIONINFOW;
	[PInvokeData("winnt.h", MSDNShortId = "NS:winnt._OSVERSIONINFOW")]
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
	public struct OSVERSIONINFOW
	{
		/// <summary>The size of this data structure, in bytes. Set this member to .</summary>
		public uint dwOSVersionInfoSize;

		/// <summary>The major version number of the operating system. For more information, see Remarks.</summary>
		public uint dwMajorVersion;

		/// <summary>The minor version number of the operating system. For more information, see Remarks.</summary>
		public uint dwMinorVersion;

		/// <summary>The build number of the operating system.</summary>
		public uint dwBuildNumber;

		/// <summary>
		/// <para>The operating system platform. This member can be the following value.</para>
		/// <list type="table">
		/// <listheader>
		/// <description>Value</description>
		/// <description>Meaning</description>
		/// </listheader>
		/// <item>
		/// <description><c>VER_PLATFORM_WIN32_NT</c> 2</description>
		/// <description>
		/// The operating system is WindowsÂ 7, Windows ServerÂ 2008, WindowsÂ Vista, Windows ServerÂ 2003, WindowsÂ XP, or WindowsÂ 2000.
		/// </description>
		/// </item>
		/// </list>
		/// </summary>
		public uint dwPlatformId;

		/// <summary>
		/// A null-terminated string, such as "Service Pack 3", that indicates the latest Service Pack installed on the system. If no
		/// Service Pack has been installed, the string is empty.
		/// </summary>
		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
		public string szCSDVersion;
	}

	/*
	ACCESS_STATE structure
	ACL structure
	ClfsCreateMarshallingAreaEx function
	DIRECTORY_NOTIFY_INFORMATION_CLASS enumeration
	DRIVER_DIRECTORY_TYPE enumeration
	ExInitializeWorkItem function
	ExQueueWorkItem function
	FAST_IO_DISPATCH structure
	FILE_INFORMATION_CLASS enumeration
	FILE_MEMORY_PARTITION_INFORMATION structure
	FILE_SFIO_RESERVE_INFORMATION structure
	FS_INFORMATION_CLASS enumeration
	IoGetTopLevelIrp function
	IoRemoveLinkShareAccessEx function
	IoSetTopLevelIrp function
	LOCK_OPERATION enumeration
	LUID_AND_ATTRIBUTES structure
	SeCaptureSubjectContext function
	SECURITY_IMPERSONATION_LEVEL enumeration
	SECURITY_SUBJECT_CONTEXT structure
	SeLockSubjectContext function
	SeReleaseSubjectContext function
	SeUnlockSubjectContext function
	VPB structure
	WORK_QUEUE_ITEM structure

	ASSERTMSG macro
	DbgBreakPoint function
	DbgBreakPointWithStatus function
	DbgPrint function
	DbgPrintEx function
	EtwActivityIdControl function
	ETWENABLECALLBACK callback function
	EtwEventEnabled function
	EtwProviderEnabled function
	EtwRegister function
	EtwUnregister function
	EtwWrite function
	EtwWriteEx function
	EtwWriteString function
	EtwWriteTransfer function
	FAULT_INFORMATION structure
	FAULT_INFORMATION_ARCH enumeration
	FAULT_INFORMATION_ARM64 structure
	FAULT_INFORMATION_ARM64_FLAGS structure
	FAULT_INFORMATION_ARM64_TYPE enumeration
	KBUGCHECK_CALLBACK_RECORD structure
	KBUGCHECK_REASON_CALLBACK_RECORD structure
	KBUGCHECK_REMOVE_PAGES structure
	KBUGCHECK_SECONDARY_DUMP_DATA_EX structure
	KBUGCHECK_TRIAGE_DUMP_DATA structure
	KdBreakPointWithStatus macro
	KdChangeOption function
	KdDisableDebugger function
	KdEnableDebugger function
	KdPrint macro
	KdPrintEx macro
	KdRefreshDebuggerNotPresent function
	KeInitializeTriageDumpDataArray function
	KTRIAGE_DUMP_DATA_ARRAY structure
	PCW_CALLBACK callback function
	PCW_CALLBACK_INFORMATION union
	PCW_CALLBACK_TYPE enumeration
	PCW_COUNTER_DESCRIPTOR structure
	PCW_COUNTER_INFORMATION structure
	PCW_DATA structure
	PCW_MASK_INFORMATION structure
	PCW_REGISTRATION_INFORMATION structure
	PcwAddInstance function
	PcwCloseInstance function
	PcwCreateInstance function
	PcwRegister function
	PcwUnregister function
	SeEtwWriteKMCveEvent function
	vDbgPrintEx function
	vDbgPrintExWithPrefix function

	DMA_ADAPTER structure
	DMA_OPERATIONS structure
	_BitTest64 function
	_BitTestAndComplement64 function
	_BitTestAndReset64 function
	_BitTestAndSet64 function
	ACPI_INTERFACE_STANDARD2 structure
	ALLOCATE_FUNCTION_EX callback function
	AppendTailList function
	ARM64_SYSREG_CRM macro
	ARM64_SYSREG_CRN macro
	ARM64_SYSREG_OP1 macro
	ARM64_SYSREG_OP2 macro
	BOOTDISK_INFORMATION structure
	BOOTDISK_INFORMATION_EX structure
	BOUND_CALLBACK callback function
	BOUND_CALLBACK_STATUS enumeration
	BUS_INTERFACE_STANDARD structure
	BUS_RESOURCE_UPDATE_INTERFACE structure
	CLFS_CONTEXT_MODE enumeration
	CLFS_LOG_NAME_INFORMATION structure
	CLFS_MGMT_CLIENT_REGISTRATION structure
	CLFS_MGMT_POLICY structure
	CLFS_MGMT_POLICY_TYPE enumeration
	CLFS_STREAM_ID_INFORMATION structure
	ClfsAddLogContainer function
	ClfsAddLogContainerSet function
	ClfsAdvanceLogBase function
	ClfsAlignReservedLog function
	ClfsAllocReservedLog function
	ClfsCloseAndResetLogFile function
	ClfsCloseLogFileObject function
	ClfsCreateLogFile function
	ClfsCreateMarshallingArea function
	ClfsCreateScanContext function
	ClfsDeleteLogByPointer function
	ClfsDeleteLogFile function
	ClfsDeleteMarshallingArea function
	ClfsFlushBuffers function
	ClfsFlushToLsn function
	ClfsGetContainerName function
	ClfsGetIoStatistics function
	ClfsLsnBlockOffset function
	ClfsLsnContainer function
	ClfsLsnCreate function
	ClfsLsnEqual function
	ClfsLsnGreater function
	ClfsLsnLess function
	ClfsLsnNull function
	ClfsLsnRecordSequence function
	ClfsMgmtDeregisterManagedClient function
	ClfsMgmtHandleLogFileFull function
	ClfsMgmtInstallPolicy function
	ClfsMgmtQueryPolicy function
	ClfsMgmtRegisterManagedClient function
	ClfsMgmtRemovePolicy function
	ClfsMgmtSetLogFileSize function
	ClfsMgmtSetLogFileSizeAsClient function
	ClfsMgmtTailAdvanceFailure function
	ClfsQueryLogFileInformation function
	ClfsReadLogRecord function
	ClfsReadNextLogRecord function
	ClfsReadPreviousRestartArea function
	ClfsReadRestartArea function
	ClfsRemoveLogContainer function
	ClfsRemoveLogContainerSet function
	ClfsReserveAndAppendLog function
	ClfsReserveAndAppendLogAligned function
	ClfsScanLogContainers function
	ClfsSetArchiveTail function
	ClfsSetEndOfLog function
	ClfsSetLogFileInformation function
	ClfsTerminateReadLog function
	ClfsWriteRestartArea function
	CLS_CONTAINER_INFORMATION structure
	CLS_INFORMATION structure
	CLS_IO_STATISTICS structure
	CLS_IO_STATISTICS_HEADER structure
	CLS_LOG_INFORMATION_CLASS enumeration
	CLS_LSN structure
	CLS_SCAN_CONTEXT structure
	CLS_WRITE_ENTRY structure
	CM_EISA_FUNCTION_INFORMATION structure
	CM_EISA_SLOT_INFORMATION structure
	CM_FLOPPY_DEVICE_DATA structure
	CM_FULL_RESOURCE_DESCRIPTOR structure
	CM_INT13_DRIVE_PARAMETER structure
	CM_KEYBOARD_DEVICE_DATA structure
	CM_MCA_POS_DATA structure
	CM_PARTIAL_RESOURCE_DESCRIPTOR structure
	CM_PARTIAL_RESOURCE_LIST structure
	CM_POWER_DATA structure
	CM_RESOURCE_LIST structure
	CM_SCSI_DEVICE_DATA structure
	CM_SERIAL_DEVICE_DATA structure
	CmCallbackGetKeyObjectID function
	CmCallbackGetKeyObjectIDEx function
	CmCallbackReleaseKeyObjectIDEx function
	CmGetBoundTransaction function
	CmGetCallbackVersion function
	CmRegisterCallback function
	CmRegisterCallbackEx function
	CmSetCallbackObjectContext function
	CmUnRegisterCallback function
	COUNTED_REASON_CONTEXT structure
	D3COLD_AUX_POWER_AND_TIMING_INTERFACE structure
	D3COLD_LAST_TRANSITION_STATUS enumeration
	D3COLD_REQUEST_AUX_POWER callback function
	D3COLD_REQUEST_CORE_POWER_RAIL callback function
	D3COLD_REQUEST_PERST_DELAY callback function
	D3COLD_SUPPORT_INTERFACE structure
	DEVICE_BUS_SPECIFIC_RESET_INFO structure
	DEVICE_BUS_SPECIFIC_RESET_TYPE union
	DEVICE_CAPABILITIES structure
	DEVICE_DESCRIPTION structure
	DEVICE_DIRECTORY_TYPE enumeration
	DEVICE_FAULT_CONFIGURATION structure
	DEVICE_INSTALL_STATE enumeration
	DEVICE_INTERFACE_CHANGE_NOTIFICATION structure
	DEVICE_OBJECT structure
	DEVICE_POWER_STATE enumeration
	DEVICE_REGISTRY_PROPERTY enumeration
	DEVICE_REMOVAL_POLICY enumeration
	DEVICE_RESET_INTERFACE_STANDARD structure
	DEVICE_RESET_TYPE enumeration
	DEVICE_USAGE_NOTIFICATION_TYPE enumeration
	DEVICE_WAKE_DEPTH enumeration
	DMA_ADAPTER_INFO structure
	DMA_ADAPTER_INFO_V1 structure
	DMA_COMMON_BUFFER_EXTENDED_CONFIGURATION_TYPE enumeration
	DMA_COMPLETION_ROUTINE callback function
	DMA_COMPLETION_STATUS enumeration
	DMA_IOMMU_INTERFACE structure
	DMA_IOMMU_INTERFACE_EX structure
	DMA_IOMMU_INTERFACE_V1 structure
	DMA_IOMMU_INTERFACE_V2 structure
	DMA_TRANSFER_INFO structure
	DMA_TRANSFER_INFO_V1 structure
	DMA_TRANSFER_INFO_V2 structure
	DOMAIN_CONFIGURATION structure
	DOMAIN_CONFIGURATION_ARCH enumeration
	DOMAIN_CONFIGURATION_ARM64 structure
	DOMAIN_CONFIGURATION_X64 structure
	DRIVER_ADD_DEVICE callback function
	DRIVER_CANCEL callback function
	DRIVER_CONTROL callback function
	DRIVER_DISPATCH callback function
	DRIVER_INITIALIZE callback function
	DRIVER_LIST_CONTROL callback function
	DRIVER_OBJECT structure
	DRIVER_REGKEY_TYPE enumeration
	DRIVER_STARTIO callback function
	DRIVER_UNLOAD callback function
	ENLISTMENT_BASIC_INFORMATION structure
	ENLISTMENT_INFORMATION_CLASS enumeration
	EX_CALLBACK_FUNCTION callback function
	EX_POOL_PRIORITY enumeration
	ExAcquirePushLockExclusive macro
	ExAcquirePushLockShared macro
	ExAcquireResourceExclusiveLite function
	ExAcquireResourceSharedLite function
	ExAcquireRundownProtection function
	ExAcquireRundownProtectionEx function
	ExAcquireSharedStarveExclusive function
	ExAcquireSharedWaitForExclusive function
	ExAllocateFromLookasideListEx function
	ExAllocateFromNPagedLookasideList function
	ExAllocateFromPagedLookasideList function
	ExAllocatePool function
	ExAllocatePool2 function
	ExAllocatePool3 function
	ExAllocatePoolPriorityUninitialized function
	ExAllocatePoolPriorityZero function
	ExAllocatePoolQuotaUninitialized function
	ExAllocatePoolQuotaZero function
	ExAllocatePoolUninitialized function
	ExAllocatePoolWithQuota function
	ExAllocatePoolWithQuotaTag function
	ExAllocatePoolWithTag function
	ExAllocatePoolWithTagPriority function
	ExAllocatePoolZero function
	ExAllocateTimer function
	ExCancelTimer function
	ExConvertExclusiveToSharedLite function
	ExCreateCallback function
	ExCreatePool function
	ExDeleteLookasideListEx function
	ExDeleteNPagedLookasideList function
	ExDeletePagedLookasideList function
	ExDeleteResourceLite function
	ExDeleteTimer function
	ExDestroyPool function
	ExFlushLookasideListEx function
	ExFreePool function
	ExFreePool2 function
	ExFreePoolWithTag function
	ExFreeToLookasideListEx function
	ExFreeToNPagedLookasideList function
	ExFreeToPagedLookasideList function
	ExGetExclusiveWaiterCount function
	ExGetFirmwareEnvironmentVariable function
	ExGetFirmwareType function
	ExGetPreviousMode function
	ExGetSharedWaiterCount function
	ExInitializeDeleteTimerParameters function
	ExInitializeDeviceAts function
	ExInitializeDriverRuntime function
	ExInitializeFastMutex function
	ExInitializeLookasideListEx function
	ExInitializeNPagedLookasideList function
	ExInitializePagedLookasideList function
	ExInitializePushLock function
	ExInitializeResourceLite function
	ExInitializeRundownProtection function
	ExInitializeSetTimerParameters function
	ExInterlockedAddLargeInteger function
	ExInterlockedAddLargeStatistic macro
	ExInterlockedAddUlong function
	ExInterlockedCompareExchange64 macro
	ExInterlockedFlushSList function
	ExInterlockedInsertHeadList function
	ExInterlockedInsertTailList function
	ExInterlockedPopEntryList function
	ExInterlockedPopEntrySList function
	ExInterlockedPushEntryList function
	ExInterlockedPushEntrySList function
	ExInterlockedRemoveHeadList function
	ExIsProcessorFeaturePresent function
	ExIsResourceAcquiredExclusiveLite function
	ExIsResourceAcquiredSharedLite function
	ExIsSoftBoot function
	ExLocalTimeToSystemTime function
	ExNotifyCallback function
	ExQueryDepthSList function
	ExQueryTimerResolution function
	ExRaiseStatus function
	ExRegisterCallback function
	ExReinitializeResourceLite function
	ExReInitializeRundownProtection function
	ExReleasePushLockExclusive macro
	ExReleasePushLockShared macro
	ExReleaseResourceForThreadLite function
	ExReleaseResourceLite function
	ExReleaseRundownProtection function
	ExReleaseRundownProtectionEx function
	ExReleaseSpinLockExclusive function
	ExReleaseSpinLockShared function
	ExRundownCompleted function
	ExSecurePoolUpdate function
	ExSecurePoolValidate function
	ExSetFirmwareEnvironmentVariable function
	ExSetResourceOwnerPointer function
	ExSetResourceOwnerPointerEx function
	ExSetTimer function
	ExSetTimerResolution function
	ExSystemTimeToLocalTime function
	EXT_CALLBACK callback function
	EXT_DELETE_CALLBACK callback function
	EXT_DELETE_PARAMETERS structure
	EXT_SET_PARAMETERS structure
	ExTryConvertSharedSpinLockExclusive function
	ExUnregisterCallback function
	ExWaitForRundownProtectionRelease function
	FIELD_OFFSET macro
	FILE_BASIC_INFORMATION structure
	FILE_FS_DEVICE_INFORMATION structure
	FILE_FULL_EA_INFORMATION structure
	FILE_IO_PRIORITY_HINT_INFORMATION structure
	FILE_IS_REMOTE_DEVICE_INFORMATION structure
	FILE_NETWORK_OPEN_INFORMATION structure
	FILE_OBJECT structure
	FILE_POSITION_INFORMATION structure
	FILE_STANDARD_INFORMATION structure
	FILE_STANDARD_INFORMATION_EX structure
	FirstEntrySList function
	FPGA_BUS_SCAN callback function
	FPGA_CONTROL_CONFIG_SPACE callback function
	FPGA_CONTROL_ERROR_REPORTING callback function
	FPGA_CONTROL_INTERFACE structure
	FPGA_CONTROL_LINK callback function
	FREE_FUNCTION_EX callback function
	FUNCTION_LEVEL_DEVICE_RESET_PARAMETERS structure
	GENERIC_MAPPING structure
	GET_D3COLD_CAPABILITY callback function
	GET_D3COLD_LAST_TRANSITION_STATUS callback function
	GET_DMA_ADAPTER callback function
	GET_IDLE_WAKE_INFO callback function
	GET_SDEV_IDENTIFIER callback function
	GET_SET_DEVICE_DATA callback function
	GET_UPDATED_BUS_RESOURCE callback function
	HWPROFILE_CHANGE_NOTIFICATION structure
	IMAGE_POLICY_ENTRY structure
	IMAGE_POLICY_ENTRY_TYPE enumeration
	IMAGE_POLICY_ID enumeration
	IMAGE_POLICY_METADATA structure
	IMAGE_POLICY_OVERRIDE macro
	InitializeListHead function
	InitializeSListHead function
	INPUT_MAPPING_ELEMENT structure
	InsertHeadList function
	InsertTailList function
	INTERFACE structure
	INTERFACE_TYPE enumeration
	InterlockedAnd function
	InterlockedCompareExchange function
	InterlockedCompareExchangePointer function
	InterlockedDecrement function
	InterlockedExchange function
	InterlockedExchangeAdd function
	InterlockedExchangePointer function
	InterlockedIncrement function
	InterlockedOr function
	InterlockedXor function
	IO_ACCESS_MODE enumeration
	IO_ACCESS_TYPE enumeration
	IO_ALLOCATION_ACTION enumeration
	IO_COMPLETION_ROUTINE callback function
	IO_CONNECT_INTERRUPT_PARAMETERS structure
	IO_CONTAINER_INFORMATION_CLASS enumeration
	IO_CONTAINER_NOTIFICATION_CLASS enumeration
	IO_CSQ_ACQUIRE_LOCK callback function
	IO_CSQ_COMPLETE_CANCELED_IRP callback function
	IO_CSQ_INSERT_IRP callback function
	IO_CSQ_INSERT_IRP_EX callback function
	IO_CSQ_PEEK_NEXT_IRP callback function
	IO_CSQ_RELEASE_LOCK callback function
	IO_CSQ_REMOVE_IRP callback function
	IO_DISCONNECT_INTERRUPT_PARAMETERS structure
	IO_DPC_ROUTINE callback function
	IO_ERROR_LOG_PACKET structure
	IO_INTERRUPT_MESSAGE_INFO structure
	IO_INTERRUPT_MESSAGE_INFO_ENTRY structure
	IO_NOTIFICATION_EVENT_CATEGORY enumeration
	IO_PAGING_PRIORITY enumeration
	IO_PRIORITY_HINT enumeration
	IO_REPORT_INTERRUPT_ACTIVE_STATE_PARAMETERS structure
	IO_RESOURCE_DESCRIPTOR structure
	IO_RESOURCE_LIST structure
	IO_RESOURCE_REQUIREMENTS_LIST structure
	IO_SECURITY_CONTEXT structure
	IO_SESSION_CONNECT_INFO structure
	IO_SESSION_EVENT enumeration
	IO_SESSION_NOTIFICATION_FUNCTION callback function
	IO_SESSION_STATE enumeration
	IO_SESSION_STATE_INFORMATION structure
	IO_SESSION_STATE_NOTIFICATION structure
	IO_STACK_LOCATION structure
	IO_STATUS_BLOCK structure
	IO_STATUS_BLOCK64 structure
	IO_TIMER_ROUTINE callback function
	IO_WORKITEM_ROUTINE callback function
	IO_WORKITEM_ROUTINE_EX callback function
	IoAcquireKsrPersistentMemory function
	IoAcquireKsrPersistentMemoryEx function
	IoAcquireRemoveLock macro
	IoAdjustPagingPathCount macro
	IoAllocateDriverObjectExtension function
	IoAllocateErrorLogEntry function
	IoAllocateIrp function
	IoAllocateIrpEx function
	IoAllocateMdl function
	IoAllocateWorkItem function
	IoAttachDevice function
	IoAttachDeviceToDeviceStack function
	IoBuildAsynchronousFsdRequest function
	IoBuildDeviceIoControlRequest function
	IoBuildPartialMdl function
	IoBuildSynchronousFsdRequest function
	IoCallDriver macro
	IoCancelIrp function
	IoCheckLinkShareAccess function
	IoCheckShareAccess function
	IoCheckShareAccessEx function
	IoConnectInterrupt function
	IoConnectInterruptEx function
	IoCopyCurrentIrpStackLocationToNext function
	IoCreateDevice function
	IoCreateFile function
	IoCreateNotificationEvent function
	IoCreateSymbolicLink function
	IoCreateSynchronizationEvent function
	IoCreateSystemThread function
	IoCreateUnprotectedSymbolicLink function
	IoCsqInitialize function
	IoCsqInitializeEx function
	IoCsqInsertIrp function
	IoCsqInsertIrpEx function
	IoCsqRemoveIrp function
	IoCsqRemoveNextIrp function
	IoDeleteDevice function
	IoDeleteSymbolicLink function
	IoDetachDevice function
	IoDisconnectInterrupt function
	IoDisconnectInterruptEx function
	IoEnumerateKsrPersistentMemoryEx function
	IofCallDriver function
	IofCompleteRequest function
	IoForwardIrpSynchronously function
	IoFreeErrorLogEntry function
	IoFreeIrp function
	IoFreeKsrPersistentMemory function
	IoFreeMdl function
	IoFreeWorkItem function
	IoGetAffinityInterrupt function
	IoGetAttachedDeviceReference function
	IoGetBootDiskInformation function
	IoGetContainerInformation function
	IoGetCurrentIrpStackLocation function
	IoGetCurrentProcess function
	IoGetDeviceDirectory function
	IoGetDeviceInterfaceAlias function
	IoGetDeviceInterfacePropertyData function
	IoGetDeviceInterfaces function
	IoGetDeviceNumaNode function
	IoGetDeviceObjectPointer function
	IoGetDeviceProperty function
	IoGetDevicePropertyData function
	IoGetDmaAdapter function
	IoGetDriverDirectory function
	IoGetDriverObjectExtension function
	IoGetFunctionCodeFromCtlCode macro
	IoGetInitialStack function
	IoGetIommuInterface function
	IoGetIommuInterfaceEx function
	IoGetIoPriorityHint function
	IoGetNextIrpStackLocation function
	IoGetRelatedDeviceObject function
	IoGetRemainingStackSize function
	IoGetStackLimits function
	IoInitializeDpcRequest function
	IoInitializeIrp function
	IoInitializeRemoveLock macro
	IoInitializeTimer function
	IoInitializeWorkItem function
	IoInvalidateDeviceRelations function
	IoInvalidateDeviceState function
	IoIs32bitProcess function
	IoIsErrorUserInduced macro
	IoIsWdmVersionAvailable function
	IoMarkIrpPending function
	IOMMU_DEVICE_CREATE callback function
	IOMMU_DEVICE_CREATION_CONFIGURATION structure
	IOMMU_DEVICE_CREATION_CONFIGURATION_ACPI structure
	IOMMU_DEVICE_CREATION_CONFIGURATION_TYPE enumeration
	IOMMU_DEVICE_DELETE callback function
	IOMMU_DEVICE_FAULT_HANDLER callback function
	IOMMU_DEVICE_QUERY_DOMAIN_TYPES callback function
	IOMMU_DMA_DOMAIN_CREATION_FLAGS union
	IOMMU_DMA_DOMAIN_TYPE enumeration
	IOMMU_DMA_LOGICAL_ADDRESS_TOKEN structure
	IOMMU_DMA_LOGICAL_ADDRESS_TOKEN_MAPPED_SEGMENT structure
	IOMMU_DMA_LOGICAL_ALLOCATOR_CONFIG structure
	IOMMU_DMA_LOGICAL_ALLOCATOR_TYPE enumeration
	IOMMU_DMA_RESERVED_REGION structure
	IOMMU_DOMAIN_ATTACH_DEVICE callback function
	IOMMU_DOMAIN_ATTACH_DEVICE_EX callback function
	IOMMU_DOMAIN_CONFIGURE callback function
	IOMMU_DOMAIN_CREATE callback function
	IOMMU_DOMAIN_CREATE_EX callback function
	IOMMU_DOMAIN_DELETE callback function
	IOMMU_DOMAIN_DETACH_DEVICE callback function
	IOMMU_DOMAIN_DETACH_DEVICE_EX callback function
	IOMMU_FLUSH_DOMAIN callback function
	IOMMU_FLUSH_DOMAIN_VA_LIST callback function
	IOMMU_FREE_RESERVED_LOGICAL_ADDRESS_RANGE callback function
	IOMMU_INTERFACE_STATE_CHANGE structure
	IOMMU_INTERFACE_STATE_CHANGE_CALLBACK callback function
	IOMMU_INTERFACE_STATE_CHANGE_FIELDS union
	IOMMU_MAP_IDENTITY_RANGE callback function
	IOMMU_MAP_IDENTITY_RANGE_EX callback function
	IOMMU_MAP_LOGICAL_RANGE callback function
	IOMMU_MAP_LOGICAL_RANGE_EX callback function
	IOMMU_MAP_PHYSICAL_ADDRESS structure
	IOMMU_MAP_PHYSICAL_ADDRESS_TYPE enumeration
	IOMMU_MAP_RESERVED_LOGICAL_RANGE callback function
	IOMMU_QUERY_INPUT_MAPPINGS callback function
	IOMMU_REGISTER_INTERFACE_STATE_CHANGE_CALLBACK callback function
	IOMMU_RESERVE_LOGICAL_ADDRESS_RANGE callback function
	IOMMU_SET_DEVICE_FAULT_REPORTING callback function
	IOMMU_SET_DEVICE_FAULT_REPORTING_EX callback function
	IOMMU_UNMAP_IDENTITY_RANGE callback function
	IOMMU_UNMAP_IDENTITY_RANGE_EX callback function
	IOMMU_UNMAP_LOGICAL_RANGE callback function
	IOMMU_UNMAP_RESERVED_LOGICAL_RANGE callback function
	IOMMU_UNREGISTER_INTERFACE_STATE_CHANGE_CALLBACK callback function
	IoOpenDeviceInterfaceRegistryKey function
	IoOpenDeviceRegistryKey function
	IoOpenDriverRegistryKey function
	IoQueryKsrPersistentMemorySize function
	IoQueryKsrPersistentMemorySizeEx function
	IoQueueWorkItem function
	IoQueueWorkItemEx function
	IoRegisterContainerNotification function
	IoRegisterDeviceInterface function
	IoRegisterLastChanceShutdownNotification function
	IoRegisterPlugPlayNotification function
	IoRegisterShutdownNotification function
	IoReleaseRemoveLock macro
	IoReleaseRemoveLockAndWait macro
	IoRemoveLinkShareAccess function
	IoRemoveShareAccess function
	IoReportInterruptActive function
	IoReportInterruptInactive function
	IoReportTargetDeviceChange function
	IoReportTargetDeviceChangeAsynchronous function
	IoRequestDeviceEject function
	IoRequestDpc function
	IoReserveKsrPersistentMemory function
	IoReserveKsrPersistentMemoryEx function
	IoReuseIrp function
	Iosb64ToIosb macro
	IosbToIosb64 macro
	IoSetCancelRoutine function
	IoSetCompletionRoutine function
	IoSetCompletionRoutineEx function
	IoSetDeviceInterfacePropertyData function
	IoSetDeviceInterfaceState function
	IoSetDevicePropertyData function
	IoSetIoPriorityHint function
	IoSetLinkShareAccess function
	IoSetNextIrpStackLocation function
	IoSetShareAccess function
	IoSetShareAccessEx function
	IoSetStartIoAttributes function
	IoSizeOfIrp macro
	IoSizeofWorkItem function
	IoStartNextPacket function
	IoStartNextPacketByKey function
	IoStartPacket function
	IoStartTimer function
	IoStopTimer function
	IoUninitializeWorkItem function
	IoUnregisterContainerNotification function
	IoUnregisterPlugPlayNotification function
	IoUnregisterPlugPlayNotificationEx function
	IoUnregisterShutdownNotification function
	IoUpdateLinkShareAccess function
	IoUpdateLinkShareAccessEx function
	IoUpdateShareAccess function
	IoValidateDeviceIoControlAccess function
	IoWithinStackLimits function
	IoWMIAllocateInstanceIds function
	IoWMIDeviceObjectToInstanceName function
	IoWMIDeviceObjectToProviderId function
	IoWMIExecuteMethod function
	IoWMIHandleToInstanceName function
	IoWMIOpenBlock function
	IoWMIQueryAllData function
	IoWMIQueryAllDataMultiple function
	IoWMIQuerySingleInstance function
	IoWMIQuerySingleInstanceMultiple function
	IoWMIRegistrationControl function
	IoWMISetNotificationCallback function
	IoWMISetSingleInstance function
	IoWMISetSingleItem function
	IoWMISuggestInstanceName function
	IoWMIWriteEvent function
	IoWriteErrorLogEntry function
	IoWriteKsrPersistentMemory function
	IRP structure
	IRQ_DEVICE_POLICY enumeration
	IRQ_PRIORITY enumeration
	IsListEmpty function
	KBUGCHECK_ADD_PAGES structure
	KBUGCHECK_CALLBACK_REASON enumeration
	KBUGCHECK_CALLBACK_ROUTINE callback function
	KBUGCHECK_DUMP_IO structure
	KBUGCHECK_DUMP_IO_TYPE enumeration
	KBUGCHECK_REASON_CALLBACK_ROUTINE callback function
	KBUGCHECK_SECONDARY_DUMP_DATA structure
	KDEFERRED_ROUTINE callback function
	KDPC_WATCHDOG_INFORMATION structure
	KE_PROCESSOR_CHANGE_NOTIFY_CONTEXT structure
	KeAcquireSpinLock macro
	KeAcquireSpinLockAtDpcLevel function
	KeAddTriageDumpDataBlock function
	KeAreAllApcsDisabled function
	KeAreApcsDisabled function
	KeBugCheckEx function
	KeCancelTimer function
	KeClearEvent function
	KeConvertAuxiliaryCounterToPerformanceCounter function
	KeConvertPerformanceCounterToAuxiliaryCounter function
	KeDelayExecutionThread function
	KeDeregisterBoundCallback function
	KeDeregisterBugCheckCallback function
	KeDeregisterBugCheckReasonCallback function
	KeDeregisterNmiCallback function
	KeDeregisterProcessorChangeCallback function
	KeEnterCriticalRegion function
	KeEnterGuardedRegion function
	KeFlushIoBuffers function
	KeFlushQueuedDpcs function
	KefReleaseSpinLockFromDpcLevel function
	KeGetCurrentIrql function
	KeGetCurrentNodeNumber function
	KeGetCurrentProcessorNumberEx function
	KeGetCurrentThread function
	KeGetProcessorIndexFromNumber function
	KeGetProcessorNumberFromIndex function
	KeGetRecommendedSharedDataAlignment function
	KeInitializeCrashDumpHeader function
	KeInitializeDeviceQueue function
	KeInitializeDpc function
	KeInitializeEvent function
	KeInitializeGuardedMutex function
	KeInitializeMutex function
	KeInitializeSemaphore function
	KeInitializeSpinLock function
	KeInitializeThreadedDpc function
	KeInitializeTimer function
	KeInitializeTimerEx function
	KeInsertByKeyDeviceQueue function
	KeInsertDeviceQueue function
	KeInsertQueueDpc function
	KeIpiGenericCall function
	KeIsExecutingDpc function
	KeLeaveCriticalRegion function
	KeLeaveGuardedRegion function
	KeLowerIrql function
	KeMemoryBarrier function
	KeQueryActiveGroupCount function
	KeQueryActiveProcessorCount function
	KeQueryActiveProcessorCountEx function
	KeQueryActiveProcessors function
	KeQueryAuxiliaryCounterFrequency function
	KeQueryDpcWatchdogInformation function
	KeQueryGroupAffinity function
	KeQueryHighestNodeNumber function
	KeQueryInterruptTime function
	KeQueryInterruptTimePrecise function
	KeQueryLogicalProcessorRelationship function
	KeQueryMaximumGroupCount function
	KeQueryMaximumProcessorCount function
	KeQueryMaximumProcessorCountEx function
	KeQueryNodeActiveAffinity function
	KeQueryNodeActiveAffinity2 function
	KeQueryNodeActiveProcessorCount function
	KeQueryNodeMaximumProcessorCount function
	KeQueryPerformanceCounter function
	KeQueryPriorityThread function
	KeQueryRuntimeThread function
	KeQuerySystemTime function
	KeQuerySystemTimePrecise function
	KeQueryTickCount macro
	KeQueryTimeIncrement function
	KeQueryTotalCycleTimeThread function
	KeQueryUnbiasedInterruptTime function
	KeRaiseIrql macro
	KeRaiseIrqlToDpcLevel function
	KeReadStateEvent function
	KeReadStateMutex function
	KeReadStateSemaphore function
	KeReadStateTimer function
	KeRegisterBoundCallback function
	KeRegisterBugCheckCallback function
	KeRegisterBugCheckReasonCallback function
	KeRegisterNmiCallback function
	KeRegisterProcessorChangeCallback function
	KeReleaseGuardedMutex function
	KeReleaseGuardedMutexUnsafe function
	KeReleaseInStackQueuedSpinLock function
	KeReleaseInStackQueuedSpinLockForDpc function
	KeReleaseInStackQueuedSpinLockFromDpcLevel function
	KeReleaseInterruptSpinLock function
	KeReleaseMutex function
	KeReleaseSemaphore function
	KeReleaseSpinLock function
	KeReleaseSpinLockForDpc function
	KeReleaseSpinLockFromDpcLevel function
	KeRemoveByKeyDeviceQueue function
	KeRemoveDeviceQueue function
	KeRemoveEntryDeviceQueue function
	KeRemoveQueueDpc function
	KeResetEvent function
	KeRestoreExtendedProcessorState function
	KeRestoreFloatingPointState function
	KeRevertToUserAffinityThreadEx function
	KeRevertToUserGroupAffinityThread function
	KERNEL_CET_CONTEXT structure
	KERNEL_SOFT_RESTART_NOTIFICATION structure
	KeSaveExtendedProcessorState function
	KeSaveFloatingPointState function
	KeSetCoalescableTimer function
	KeSetEvent function
	KeSetImportanceDpc function
	KeSetPriorityThread function
	KeSetSystemAffinityThread function
	KeSetSystemAffinityThreadEx function
	KeSetSystemGroupAffinityThread function
	KeSetTargetProcessorDpc function
	KeSetTargetProcessorDpcEx function
	KeSetTimer function
	KeSetTimerEx function
	KeShouldYieldProcessor function
	KeStallExecutionProcessor function
	KeSynchronizeExecution function
	KeTestSpinLock function
	KeTryToAcquireGuardedMutex function
	KeTryToAcquireSpinLockAtDpcLevel function
	KeWaitForMultipleObjects function
	KeWaitForSingleObject function
	KEY_BASIC_INFORMATION structure
	KEY_FULL_INFORMATION structure
	KEY_INFORMATION_CLASS enumeration
	KEY_NODE_INFORMATION structure
	KEY_SET_INFORMATION_CLASS enumeration
	KEY_VALUE_BASIC_INFORMATION structure
	KEY_VALUE_ENTRY structure
	KEY_VALUE_FULL_INFORMATION structure
	KEY_VALUE_INFORMATION_CLASS enumeration
	KEY_VALUE_PARTIAL_INFORMATION structure
	KEY_WRITE_TIME_INFORMATION structure
	KINTERRUPT_MODE enumeration
	KINTERRUPT_POLARITY enumeration
	KIPI_BROADCAST_WORKER callback function
	KMESSAGE_SERVICE_ROUTINE callback function
	KMUTANT structure
	KSERVICE_ROUTINE callback function
	KSTART_ROUTINE callback function
	KSYNCHRONIZE_ROUTINE callback function
	KTMOBJECT_CURSOR structure
	KTMOBJECT_TYPE enumeration
	KzLowerIrql function
	KzRaiseIrql function
	LINK_SHARE_ACCESS structure
	MAILSLOT_CREATE_PARAMETERS structure
	MDL structure
	MEM_EXTENDED_PARAMETER structure
	MEM_EXTENDED_PARAMETER_TYPE enumeration
	MEM_SECTION_EXTENDED_PARAMETER_TYPE enumeration
	MEMORY_CACHING_TYPE enumeration
	MEMORY_PARTITION_DEDICATED_MEMORY_OPEN_INFORMATION structure
	MM_MDL_ROUTINE callback function
	MM_PHYSICAL_ADDRESS_LIST structure
	MmAdvanceMdl function
	MmAllocateContiguousMemory function
	MmAllocateContiguousMemoryEx function
	MmAllocateContiguousMemorySpecifyCache function
	MmAllocateContiguousMemorySpecifyCacheNode function
	MmAllocateContiguousNodeMemory function
	MmAllocateMappingAddress function
	MmAllocateMappingAddressEx function
	MmAllocateMdlForIoSpace function
	MmAllocateNodePagesForMdlEx function
	MmAllocatePagesForMdl function
	MmAllocatePagesForMdlEx function
	MmBuildMdlForNonPagedPool function
	MmFreeContiguousMemory function
	MmFreeContiguousMemorySpecifyCache function
	MmFreeMappingAddress function
	MmFreePagesFromMdl function
	MmGetMdlByteCount macro
	MmGetSystemAddressForMdl macro
	MmGetSystemRoutineAddress function
	MmGetSystemRoutineAddressEx function
	MmIsDriverSuspectForVerifier function
	MmIsDriverVerifying function
	MmIsDriverVerifyingByAddress function
	MmLockPagableCodeSection macro
	MmLockPagableDataSection function
	MmMapIoSpace function
	MmMapIoSpaceEx function
	MmMapLockedPages function
	MmMapLockedPagesSpecifyCache function
	MmMapLockedPagesWithReservedMapping function
	MmMapMdl function
	MmMapMemoryDumpMdlEx function
	MmPageEntireDriver function
	MmProbeAndLockPages function
	MmProbeAndLockSelectedPages function
	MmProtectDriverSection function
	MmProtectMdlSystemAddress function
	MmQuerySystemSize function
	MmResetDriverPaging function
	MmSizeOfMdl function
	MmUnlockPagableImageSection function
	MmUnlockPages function
	MmUnmapIoSpace function
	MmUnmapLockedPages function
	MmUnmapReservedMapping function
	MONITOR_DISPLAY_STATE enumeration
	NAMED_PIPE_CREATE_PARAMETERS structure
	NtCommitComplete function
	NtCommitEnlistment function
	NtCommitTransaction function
	NtCreateEnlistment function
	NtCreateResourceManager function
	NtCreateTransaction function
	NtCreateTransactionManager function
	NtEnumerateTransactionObject function
	NtGetNotificationResourceManager function
	NtManagePartition function
	NtOpenEnlistment function
	NtOpenResourceManager function
	NtOpenTransaction function
	NtOpenTransactionManager function
	NtPowerInformation function
	NtPrepareComplete function
	NtPrepareEnlistment function
	NtPrePrepareComplete function
	NtPrePrepareEnlistment function
	NtQueryInformationEnlistment function
	NtQueryInformationResourceManager function
	NtQueryInformationTransaction function
	NtQueryInformationTransactionManager function
	NtReadOnlyEnlistment function
	NtRecoverEnlistment function
	NtRecoverResourceManager function
	NtRecoverTransactionManager function
	NtRenameTransactionManager function
	NtRollbackComplete function
	NtRollbackEnlistment function
	NtRollbackTransaction function
	NtRollforwardTransactionManager function
	NtSetInformationEnlistment function
	NtSetInformationResourceManager function
	NtSetInformationTransaction function
	NtSetInformationTransactionManager function
	NtSinglePhaseReject function
	OB_CALLBACK_REGISTRATION structure
	OB_OPERATION_REGISTRATION structure
	OB_POST_CREATE_HANDLE_INFORMATION structure
	OB_POST_DUPLICATE_HANDLE_INFORMATION structure
	OB_POST_OPERATION_INFORMATION structure
	OB_POST_OPERATION_PARAMETERS union
	OB_PRE_CREATE_HANDLE_INFORMATION structure
	OB_PRE_DUPLICATE_HANDLE_INFORMATION structure
	OB_PRE_OPERATION_INFORMATION structure
	OB_PRE_OPERATION_PARAMETERS union
	ObCloseHandle function
	ObDereferenceObject macro
	ObDereferenceObjectDeferDelete function
	ObDereferenceObjectDeferDeleteWithTag function
	ObDereferenceObjectWithTag macro
	ObfReferenceObject function
	ObGetObjectSecurity function
	ObReferenceObject macro
	ObReferenceObjectByHandle function
	ObReferenceObjectByHandleWithTag function
	ObReferenceObjectByPointer function
	ObReferenceObjectByPointerWithTag function
	ObReferenceObjectSafe function
	ObReferenceObjectWithTag macro
	ObRegisterCallbacks function
	ObReleaseObjectSecurity function
	ObUnRegisterCallbacks function
	OSVERSIONINFOEXW structure
	OSVERSIONINFOW structure
	PALLOCATE_ADAPTER_CHANNEL callback function
	PALLOCATE_ADAPTER_CHANNEL_EX callback function
	PALLOCATE_COMMON_BUFFER callback function
	PALLOCATE_COMMON_BUFFER_EX callback function
	PALLOCATE_COMMON_BUFFER_VECTOR callback function
	PALLOCATE_COMMON_BUFFER_WITH_BOUNDS callback function
	PALLOCATE_DOMAIN_COMMON_BUFFER callback function
	PBUILD_MDL_FROM_SCATTER_GATHER_LIST callback function
	PBUILD_SCATTER_GATHER_LIST callback function
	PBUILD_SCATTER_GATHER_LIST_EX callback function
	PCALCULATE_SCATTER_GATHER_LIST_SIZE callback function
	PCANCEL_ADAPTER_CHANNEL callback function
	PCANCEL_MAPPED_TRANSFER callback function
	PCI_ATS_INTERFACE structure
	PCI_COMMON_CONFIG structure
	PCI_MSIX_MASKUNMASK_ENTRY callback function
	PCI_MSIX_SET_ENTRY callback function
	PCI_MSIX_TABLE_CONFIG_INTERFACE structure
	PCI_SECURITY_INTERFACE2 structure
	PCI_SEGMENT_BUS_NUMBER structure
	PCI_SLOT_NUMBER structure
	PCLFS_CLIENT_ADVANCE_TAIL_CALLBACK callback function
	PCLFS_CLIENT_LFF_HANDLER_COMPLETE_CALLBACK callback function
	PCLFS_CLIENT_LOG_UNPINNED_CALLBACK callback function
	PCONFIGURE_ADAPTER_CHANNEL callback function
	PDEVICE_RESET_HANDLER callback function
	PFLUSH_ADAPTER_BUFFERS callback function
	PFLUSH_ADAPTER_BUFFERS_EX callback function
	PFLUSH_DMA_BUFFER callback function
	PFREE_ADAPTER_CHANNEL callback function
	PFREE_ADAPTER_OBJECT callback function
	PFREE_COMMON_BUFFER callback function
	PFREE_COMMON_BUFFER_FROM_VECTOR callback function
	PFREE_COMMON_BUFFER_VECTOR callback function
	PFREE_MAP_REGISTERS callback function
	PGET_COMMON_BUFFER_FROM_VECTOR_BY_INDEX callback function
	PGET_DEVICE_RESET_STATUS callback function
	PGET_DMA_ADAPTER_INFO callback function
	PGET_DMA_ALIGNMENT callback function
	PGET_DMA_DOMAIN callback function
	PGET_DMA_TRANSFER_INFO callback function
	PGET_SCATTER_GATHER_LIST callback function
	PGET_SCATTER_GATHER_LIST_EX callback function
	PINITIALIZE_DMA_TRANSFER_CONTEXT callback function
	PINTERFACE_DEREFERENCE callback function
	PINTERFACE_REFERENCE callback function
	PJOIN_DMA_DOMAIN callback function
	PLEAVE_DMA_DOMAIN callback function
	PLUGPLAY_NOTIFICATION_HEADER structure
	PMAP_TRANSFER callback function
	PMAP_TRANSFER_EX callback function
	PNP_BUS_INFORMATION structure
	PO_FX_COMPONENT_ACTIVE_CONDITION_CALLBACK callback function
	PO_FX_COMPONENT_CRITICAL_TRANSITION_CALLBACK callback function
	PO_FX_COMPONENT_IDLE_CONDITION_CALLBACK callback function
	PO_FX_COMPONENT_IDLE_STATE structure
	PO_FX_COMPONENT_IDLE_STATE_CALLBACK callback function
	PO_FX_COMPONENT_PERF_INFO structure
	PO_FX_COMPONENT_PERF_SET structure
	PO_FX_COMPONENT_PERF_STATE_CALLBACK callback function
	PO_FX_COMPONENT_V1 structure
	PO_FX_COMPONENT_V2 structure
	PO_FX_DEVICE_POWER_NOT_REQUIRED_CALLBACK callback function
	PO_FX_DEVICE_POWER_REQUIRED_CALLBACK callback function
	PO_FX_DEVICE_V1 structure
	PO_FX_DEVICE_V2 structure
	PO_FX_DEVICE_V3 structure
	PO_FX_DIRECTED_POWER_DOWN_CALLBACK callback function
	PO_FX_DIRECTED_POWER_UP_CALLBACK callback function
	PO_FX_PERF_STATE structure
	PO_FX_PERF_STATE_CHANGE structure
	PO_FX_PERF_STATE_TYPE enumeration
	PO_FX_PERF_STATE_UNIT enumeration
	PO_FX_POWER_CONTROL_CALLBACK callback function
	POB_POST_OPERATION_CALLBACK callback function
	POB_PRE_OPERATION_CALLBACK callback function
	PoCallDriver function
	PoClearPowerRequest function
	PoCreatePowerRequest function
	PoDeletePowerRequest function
	PoEndDeviceBusy function
	PoFxActivateComponent function
	PoFxCompleteDevicePowerNotRequired function
	PoFxCompleteDirectedPowerDown function
	PoFxCompleteIdleCondition function
	PoFxCompleteIdleState function
	PoFxIdleComponent function
	PoFxIssueComponentPerfStateChange function
	PoFxIssueComponentPerfStateChangeMultiple function
	PoFxNotifySurprisePowerOn function
	PoFxPowerControl function
	PoFxPowerOnCrashdumpDevice function
	PoFxQueryCurrentComponentPerfState function
	PoFxRegisterComponentPerfStates function
	PoFxRegisterCrashdumpDevice function
	PoFxRegisterDevice function
	PoFxReportDevicePoweredOn function
	PoFxSetComponentLatency function
	PoFxSetComponentResidency function
	PoFxSetComponentWake function
	PoFxSetDeviceIdleTimeout function
	PoFxSetTargetDripsDevicePowerState function
	PoFxStartDevicePowerManagement function
	PoFxUnregisterDevice function
	PoGetSystemWake function
	POOL_CREATE_EXTENDED_PARAMS structure
	POOL_EXTENDED_PARAMETER structure
	POOL_EXTENDED_PARAMETER_TYPE enumeration
	POOL_EXTENDED_PARAMS_SECURE_POOL structure
	POOL_TYPE enumeration
	PopEntryList function
	PoQueryWatchdogTime function
	PoRegisterDeviceForIdleDetection function
	PoRegisterPowerSettingCallback function
	PoRegisterSystemState function
	PoRequestPowerIrp function
	PoSetDeviceBusyEx function
	PoSetPowerRequest function
	PoSetPowerState function
	PoSetSystemState function
	PoSetSystemWake function
	PoSetSystemWakeDevice function
	PoStartDeviceBusy function
	PoStartNextPowerIrp function
	PoUnregisterPowerSettingCallback function
	PoUnregisterSystemState function
	POWER_ACTION enumeration
	POWER_INFORMATION_LEVEL enumeration
	POWER_PLATFORM_INFORMATION structure
	POWER_REQUEST_TYPE enumeration
	POWER_SESSION_ALLOW_EXTERNAL_DMA_DEVICES structure
	POWER_STATE union
	POWER_STATE_TYPE enumeration
	PPUT_DMA_ADAPTER callback function
	PPUT_SCATTER_GATHER_LIST callback function
	PREAD_DMA_COUNTER callback function
	PREENUMERATE_SELF callback function
	PRIVILEGE_SET structure
	ProbeForRead function
	ProbeForWrite function
	PROCESSOR_HALT_ROUTINE callback function
	PsAllocateAffinityToken function
	PsCreateSystemThread function
	PsFreeAffinityToken function
	PsGetCurrentThread function
	PsGetVersion function
	PsQueryTotalCycleTimeProcess function
	PsRevertToUserMultipleGroupAffinityThread function
	PsSetSystemMultipleGroupAffinityThread function
	PsTerminateSystemThread function
	PTM_CONTROL_INTERFACE structure
	PTM_RM_NOTIFICATION callback function
	PushEntryList function
	READ_PORT_BUFFER_UCHAR function
	READ_PORT_BUFFER_ULONG function
	READ_PORT_BUFFER_USHORT function
	READ_PORT_UCHAR function
	READ_PORT_ULONG function
	READ_PORT_USHORT function
	READ_REGISTER_BUFFER_UCHAR function
	READ_REGISTER_BUFFER_ULONG function
	READ_REGISTER_BUFFER_ULONG64 function
	READ_REGISTER_BUFFER_USHORT function
	READ_REGISTER_UCHAR function
	READ_REGISTER_ULONG function
	READ_REGISTER_ULONG64 function
	READ_REGISTER_USHORT function
	ReadInt32Acquire function
	ReadInt32NoFence function
	ReadInt32Raw function
	ReadUInt32Acquire function
	ReadUInt32NoFence function
	ReadUInt32Raw function
	REENUMERATE_SELF_INTERFACE_STANDARD structure
	REG_CALLBACK_CONTEXT_CLEANUP_INFORMATION structure
	REG_CREATE_KEY_INFORMATION structure
	REG_CREATE_KEY_INFORMATION_V1 structure
	REG_DELETE_KEY_INFORMATION structure
	REG_DELETE_VALUE_KEY_INFORMATION structure
	REG_ENUMERATE_KEY_INFORMATION structure
	REG_ENUMERATE_VALUE_KEY_INFORMATION structure
	REG_KEY_HANDLE_CLOSE_INFORMATION structure
	REG_LOAD_KEY_INFORMATION structure
	REG_LOAD_KEY_INFORMATION_V2 structure
	REG_NOTIFY_CLASS enumeration
	REG_POST_CREATE_KEY_INFORMATION structure
	REG_POST_OPERATION_INFORMATION structure
	REG_PRE_CREATE_KEY_INFORMATION structure
	REG_QUERY_KEY_INFORMATION structure
	REG_QUERY_KEY_NAME structure
	REG_QUERY_KEY_SECURITY_INFORMATION structure
	REG_QUERY_MULTIPLE_VALUE_KEY_INFORMATION structure
	REG_QUERY_VALUE_KEY_INFORMATION structure
	REG_RENAME_KEY_INFORMATION structure
	REG_REPLACE_KEY_INFORMATION structure
	REG_RESTORE_KEY_INFORMATION structure
	REG_SAVE_KEY_INFORMATION structure
	REG_SAVE_MERGED_KEY_INFORMATION structure
	REG_SET_INFORMATION_KEY_INFORMATION structure
	REG_SET_KEY_SECURITY_INFORMATION structure
	REG_SET_VALUE_KEY_INFORMATION structure
	REG_UNLOAD_KEY_INFORMATION structure
	RemoveEntryList function
	RemoveHeadList function
	RemoveTailList function
	REQUEST_POWER_COMPLETE callback function
	RESOURCEMANAGER_BASIC_INFORMATION structure
	RESOURCEMANAGER_COMPLETION_INFORMATION structure
	RESOURCEMANAGER_INFORMATION_CLASS enumeration
	RTL_QUERY_REGISTRY_ROUTINE callback function
	RtlAnsiStringToUnicodeSize macro
	RtlAnsiStringToUnicodeString function
	RtlAppendUnicodeStringToString function
	RtlAppendUnicodeToString function
	RtlAreBitsClear function
	RtlAreBitsSet function
	RtlCheckBit function
	RtlCheckRegistryKey function
	RtlClearAllBits function
	RtlClearBit function
	RtlClearBits function
	RtlCmDecodeMemIoResource function
	RtlCmEncodeMemIoResource function
	RtlCompareMemory function
	RtlCompareUnicodeString function
	RtlConvertLongToLargeInteger function
	RtlConvertUlongToLargeInteger function
	RtlCopyMemory macro
	RtlCopyMemoryNonTemporal function
	RtlCopyUnicodeString function
	RtlCreateRegistryKey function
	RtlCreateSecurityDescriptor function
	RtlDeleteRegistryValue function
	RtlDowncaseUnicodeChar function
	RtlEqualMemory macro
	RtlEqualUnicodeString function
	RtlFillMemory macro
	RtlFillMemoryNonTemporal function
	RtlFindClearBits function
	RtlFindClearBitsAndSet function
	RtlFindClearRuns function
	RtlFindFirstRunClear function
	RtlFindLastBackwardRunClear function
	RtlFindLeastSignificantBit function
	RtlFindLongestRunClear function
	RtlFindMostSignificantBit function
	RtlFindNextForwardRunClear function
	RtlFindSetBits function
	RtlFindSetBitsAndClear function
	RtlFreeAnsiString function
	RtlFreeUnicodeString function
	RtlFreeUTF8String function
	RtlGetVersion function
	RtlGUIDFromString function
	RtlHashUnicodeString function
	RtlInitAnsiString function
	RtlInitializeBitMap function
	RtlInitString function
	RtlInitStringEx function
	RtlInitUnicodeString function
	RtlInitUTF8String function
	RtlInitUTF8StringEx function
	RtlInt64ToUnicodeString function
	RtlIntegerToUnicodeString function
	RtlIntPtrToUnicodeString macro
	RtlIoDecodeMemIoResource function
	RtlIoEncodeMemIoResource function
	RtlIsNtDdiVersionAvailable function
	RtlIsServicePackVersionInstalled function
	RtlLengthSecurityDescriptor function
	RtlMoveMemory macro
	RtlNumberOfClearBits function
	RtlNumberOfSetBits function
	RtlNumberOfSetBitsUlongPtr function
	RtlPrefetchMemoryNonTemporal function
	RtlQueryRegistryValues function
	RtlSanitizeUnicodeStringPadding function
	RtlSecureZeroMemory function
	RtlSetAllBits function
	RtlSetBit function
	RtlSetBits function
	RtlSetDaclSecurityDescriptor function
	RtlStringFromGUID function
	RtlTestBit function
	RtlTimeFieldsToTime function
	RtlTimeToTimeFields function
	RtlUlongByteSwap function
	RtlUlonglongByteSwap function
	RtlUnicodeStringToAnsiSize macro
	RtlUnicodeStringToAnsiString function
	RtlUnicodeStringToInteger function
	RtlUnicodeStringToUTF8String function
	RtlUnicodeToUTF8N function
	RtlUpcaseUnicodeChar function
	RtlUshortByteSwap function
	RtlUTF8StringToUnicodeString function
	RtlUTF8ToUnicodeN function
	RtlValidRelativeSecurityDescriptor function
	RtlValidSecurityDescriptor function
	RtlVerifyVersionInfo function
	RtlWriteRegistryValue function
	RtlxAnsiStringToUnicodeSize function
	RtlxUnicodeStringToAnsiSize function
	RtlZeroMemory macro
	SCATTER_GATHER_LIST structure
	SDEV_IDENTIFIER_INTERFACE structure
	SE_IMAGE_TYPE enumeration
	SeAccessCheck function
	SeAssignSecurity function
	SeAssignSecurityEx function
	SECTION_OBJECT_POINTERS structure
	SeDeassignSecurity function
	SET_D3COLD_SUPPORT callback function
	SeValidSecurityDescriptor function
	SLIST_ENTRY structure
	SYSTEM_POOL_ZEROING_INFORMATION structure
	SYSTEM_POWER_STATE enumeration
	SYSTEM_POWER_STATE_CONTEXT structure
	TARGET_DEVICE_CUSTOM_NOTIFICATION structure
	TARGET_DEVICE_REMOVAL_NOTIFICATION structure
	TIME_FIELDS structure
	TmCommitComplete function
	TmCommitEnlistment function
	TmCommitTransaction function
	TmCreateEnlistment function
	TmDereferenceEnlistmentKey function
	TmEnableCallbacks function
	TmGetTransactionId function
	TmInitializeTransactionManager function
	TmIsTransactionActive function
	TmPrepareComplete function
	TmPrepareEnlistment function
	TmPrePrepareComplete function
	TmPrePrepareEnlistment function
	TmReadOnlyEnlistment function
	TmRecoverEnlistment function
	TmRecoverResourceManager function
	TmRecoverTransactionManager function
	TmReferenceEnlistmentKey function
	TmRenameTransactionManager function
	TmRequestOutcomeEnlistment function
	TmRollbackComplete function
	TmRollbackEnlistment function
	TmRollbackTransaction function
	TmSinglePhaseReject function
	TRACE_INFORMATION_CLASS enumeration
	TRANSACTION_BASIC_INFORMATION structure
	TRANSACTION_ENLISTMENT_PAIR structure
	TRANSACTION_ENLISTMENTS_INFORMATION structure
	TRANSACTION_INFORMATION_CLASS enumeration
	TRANSACTION_OUTCOME enumeration
	TRANSACTION_PROPERTIES_INFORMATION structure
	TRANSACTION_STATE enumeration
	TRANSACTIONMANAGER_BASIC_INFORMATION structure
	TRANSACTIONMANAGER_INFORMATION_CLASS enumeration
	TRANSACTIONMANAGER_LOG_INFORMATION structure
	TRANSACTIONMANAGER_LOGPATH_INFORMATION structure
	TRANSACTIONMANAGER_RECOVERY_INFORMATION structure
	TRANSLATE_BUS_ADDRESS callback function
	VslCreateSecureSection function
	VslDeleteSecureSection function
	WAIT_CONTEXT_BLOCK structure
	WmiQueryTraceInformation function
	WmiTraceMessage function
	WmiTraceMessageVa function
	WORK_QUEUE_TYPE enumeration
	WRITE_PORT_BUFFER_UCHAR function
	WRITE_PORT_BUFFER_ULONG function
	WRITE_PORT_BUFFER_USHORT function
	WRITE_PORT_UCHAR function
	WRITE_PORT_ULONG function
	WRITE_PORT_USHORT function
	WRITE_REGISTER_BUFFER_UCHAR function
	WRITE_REGISTER_BUFFER_ULONG function
	WRITE_REGISTER_BUFFER_ULONG64 function
	WRITE_REGISTER_BUFFER_USHORT function
	WRITE_REGISTER_UCHAR function
	WRITE_REGISTER_ULONG function
	WRITE_REGISTER_ULONG64 function
	WRITE_REGISTER_USHORT function
	WriteInt32NoFence function
	WriteInt32Raw function
	WriteInt32Release function
	WriteUInt32NoFence function
	WriteUInt32Raw function
	WriteUInt32Release function
	XSAVE_CET_U_FORMAT structure
	ZwClose function
	ZwCommitComplete function
	ZwCommitEnlistment function
	ZwCommitTransaction function
	ZwCreateDirectoryObject function
	ZwCreateEnlistment function
	ZwCreateFile function
	ZwCreateKey function
	ZwCreateKeyTransacted function
	ZwCreateResourceManager function
	ZwCreateSection function
	ZwCreateTransaction function
	ZwCreateTransactionManager function
	ZwDeleteKey function
	ZwDeleteValueKey function
	ZwEnumerateKey function
	ZwEnumerateTransactionObject function
	ZwEnumerateValueKey function
	ZwFlushKey function
	ZwGetNotificationResourceManager function
	ZwLoadDriver function
	ZwMakeTemporaryObject function
	ZwMapViewOfSection function
	ZwOpenEnlistment function
	ZwOpenEvent function
	ZwOpenFile function
	ZwOpenKey function
	ZwOpenKeyEx function
	ZwOpenKeyTransacted function
	ZwOpenKeyTransactedEx function
	ZwOpenResourceManager function
	ZwOpenSection function
	ZwOpenSymbolicLinkObject function
	ZwOpenTransaction function
	ZwOpenTransactionManager function
	ZwPrepareComplete function
	ZwPrepareEnlistment function
	ZwPrePrepareComplete function
	ZwPrePrepareEnlistment function
	ZwQueryFullAttributesFile function
	ZwQueryInformationByName function
	ZwQueryInformationEnlistment function
	ZwQueryInformationFile function
	ZwQueryInformationResourceManager function
	ZwQueryInformationTransaction function
	ZwQueryInformationTransactionManager function
	ZwQueryKey function
	ZwQuerySymbolicLinkObject function
	ZwQueryValueKey function
	ZwReadFile function
	ZwReadOnlyEnlistment function
	ZwRecoverEnlistment function
	ZwRecoverResourceManager function
	ZwRecoverTransactionManager function
	ZwRollbackComplete function
	ZwRollbackEnlistment function
	ZwRollbackTransaction function
	ZwRollforwardTransactionManager function
	ZwSetInformationEnlistment function
	ZwSetInformationFile function
	ZwSetInformationResourceManager function
	ZwSetInformationTransaction function
	ZwSetValueKey function
	ZwSinglePhaseReject function
	ZwUnloadDriver function
	ZwUnmapViewOfSection function
	ZwWriteFile function
	*/
}